Wikibooks plwikibooks https://pl.wikibooks.org/wiki/Wikibooks:Strona_g%C5%82%C3%B3wna MediaWiki 1.47.0-wmf.19 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 555703 553522 2026-09-11T15:23:54Z Persino 2851 555703 Scribunto text/plain local p={}; p["LiczbaElementówNumerowanychTablicy"]=function(tabela, niepuste_wliczac,mnoga) local liczba_elementow_ponumerowanych_w_tablicy=0; local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); local czy_mnoga=p.CzyTak(mnoga); for _1,_2 in ipairs(tabela)do if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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,niepuste_wliczac,mnoga) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_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_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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,niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); local liczba_elementow_w_tablicy=0; for _1,_2 in pairs(tabela)do if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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,niepuste_wliczac,czy_formy_numerkowe) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_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_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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, niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); local liczba_elementow_ponumerowanych_w_tablicy=0; for _1,_2 in pairs(tabela)do if(type(_1)=="number")then if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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,niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); local liczba_elementow_ponumerowanych_w_tablicy; for _1,_2 in pairs(tabela)do if(type(_1)=="number")then if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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.MinimalnyIMaksymalnyNumerPodstawyParametruTabeli(tabela,podstawa_parametru, czy_od_zera) 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,"^"..podstawa_parametru.."%s(%d+)$") if(liczba_z_parametru)then local liczba=tonumber(liczba_z_parametru) or (czy_od_zera and 0 or 1); liczba=(liczba>0)and liczba or (czy_od_zera and 0 or 1); liczba_maksimum=math.max(liczba_maksimum,liczba); if(not liczba_minimum)then liczba_minimum=liczba; else liczba_minimum=math.min(liczba_minimum,liczba); end; elseif(podstawa_parametru==nazwa_parametru)then liczba_maksimum=math.max(liczba_maksimum,(czy_od_zera and 0 or 1)); if(not liczba_minimum)then liczba_minimum=czy_od_zera and 0 or 1; else liczba_minimum=math.min(liczba_minimum,czy_od_zera and 0 or 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,niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); for _1,_2 in ipairs(tabela)do if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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,niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); for _1,_2 in pairs(tabela)do if(type(_1)=="number")then if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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,niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); for _1,_2 in pairs(tabela)do if(type(_1)~="number")then if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_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,niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); for _1,_2 in pairs(tabela)do if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_wliczac)and(p.CzyTak(_2))))then return true; end; end; return false; end; p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame) local parametry_modul=require("Module:Parametry"); local czy_jest_taki_element=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); if(czy_jest_taki_element)then return "tak";end; end; p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,niepuste_wliczac) local czy_tylko_niepuste_wliczac=p.CzyTak(niepuste_wliczac); local i=1; local czy=false; for _1,_2 in pairs(args)do if(type(_1)=="number")then if((not czy_tylko_niepuste_wliczac)or((czy_tylko_niepuste_wliczac)and(p.CzyTak(_2))))then if(_1==1)then czy=true;end; if(i>1)then return false; else i=i+1; end; end; end; end; if((czy)or(i==1))then return true;end; return false; end; p["KopiujTabelęŁańcuchów"]=function(args) local args2={}; local wzor_temp=args["wzór"];local wzor_wszystko=args["wzór wszystko"]; local podstawienie_temp=args.podstawienie;local podstawienie_wszystko=args["podstawienie wszystko"]; local wzor2_temp=args["wzór 2"];local wzor_wszystko_2=args["wzór wszystko 2"]; local przedrostek_temp=args.przedrostek;local przedrostek_wszystko=args["przedrostek wszystko"]; local przyrostek_temp=args.przyrostek;local przyrostek_wszystko=args["przyrostek wszystko"]; for name,value in pairs(args.tabela)do local wzor=wzor_temp and wzor_temp[name] or wzor_wszystko; local podstawienie=wzor and (podstawienie_temp and podstawienie_temp[name] or podstawienie_wszystko) or nil; if(wzor and podstawienie)then value=mw.ustring.gsub(value,wzor,podstawienie);end; local wzor2=wzor2_temp and wzor2_temp[name] or wzor_wszystko_2; if(wzor2)then value=mw.ustring.match(value,wzor2);end; if(value)then local przedrostek=przedrostek_temp and przedrostek_temp[name] or przedrostek_wszystko; local przyrostek=przyrostek_temp and przyrostek_temp[name] or przyrostek_wszystko; args2[name]=(przedrostek or '')..value..(przyrostek or ''); end; end; return args2; end; p["KopiujTabelęElementów"]=function(tabelka,niepuste_wliczac_nazwy,niepuste_wliczac_wartosci) local czy_tylko_niepuste_wliczac_nazwy=p.CzyTak(niepuste_wliczac_nazwy); local czy_tylko_niepuste_wliczac_wartosci=p.CzyTak(niepuste_wliczac_wartosci); local tabelka2={}; for name,value in pairs(tabelka)do if(((not czy_tylko_niepuste_wliczac_nazwy)or((czy_tylko_niepuste_wliczac_nazwy)and(p.CzyTak(name))))and((not czy_tylko_niepuste_wliczac_wartosci)or((czy_tylko_niepuste_wliczac_wartosci)and(p.CzyTak(value)))))then tabelka2[name]=value; end; end; return tabelka2; end; p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,niepuste_wliczac_nazwy,niepuste_wliczac_wartosci) local czy_tylko_niepuste_wliczac_nazwy=p.CzyTak(niepuste_wliczac_nazwy); local czy_tylko_niepuste_wliczac_wartosci=p.CzyTak(niepuste_wliczac_wartosci); local tabelka3={}; for name,value in pairs(tabelka)do if(((not czy_tylko_niepuste_wliczac_nazwy)or((czy_tylko_niepuste_wliczac_nazwy)and(p.CzyTak(name))))and((not czy_tylko_niepuste_wliczac_wartosci)or((czy_tylko_niepuste_wliczac_wartosci)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,niepuste_wliczac_nazwy,niepuste_wliczac_wartosci) local czy_tylko_niepuste_wliczac_nazwy=p.CzyTak(niepuste_wliczac_nazwy); local czy_tylko_niepuste_wliczac_wartosci=p.CzyTak(niepuste_wliczac_wartosci); local szablonowe_potrzebne_modul=require("Module:Szablonowe/Potrzebne"); local szablonowe_modul=require("Module:Szablonowe"); local kopiuj_metatable=function(value,funkcja,funkcja2) local __metatabelka=getmetatable(value); if(__metatabelka)then if(__metatabelka.KopiujMetaTabela)then __metatabelka.KopiujMetaTabela(value,funkcja,funkcja2) else funkcja(value,true); end; 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_tylko_niepuste_wliczac_nazwy)or((czy_tylko_niepuste_wliczac_nazwy)and(p.CzyTak(name))))and((not czy_tylko_niepuste_wliczac_wartosci)or((czy_tylko_niepuste_wliczac_wartosci)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=p["Odstępy"]{[1]=klucz,[2]="tak",}; 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,czy_number,funkcja) local keys={}; for name,_ in next,tabela do if((not czy_number)or((czy_number)and(p.TypeNumber(name))))then table.insert(keys,name); end; end; table.sort(keys, funkcja or ((czy_number) and function(a,b) return (a<b); end or nil ) ); return function(tablica,klucz) if(klucz==nil)then local klucz=keys[1]; return klucz,tablica[klucz]; end; for k,_ in ipairs(keys)do if(keys[k]==klucz)then local klucz=keys[k+1]; return klucz,tablica[klucz]; 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; izfvnzke0ghhl85w153o4rr52gfa9tv 12 59247 555728 554178 2026-09-11T17:45:23Z Persino 2851 /* Wstęp */ 555728 wikitext text/x-wiki <noinclude><!-- -->{{UnikatowaStronaStart | nagłówek = {{Rozdział|Pomoc Wikibooks - Wstęp}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Rozdział|Koniec}} }}</noinclude> == Wstęp == * {{lr|Witamy nowicjuszy}} - ta strona jest dla nowych użytkowników polskiego {{NS|l=tak|pk=d}}, mówi jak czytać, przeglądać w księgozbiór, jak usuwać błędy z artykułów, pisania nowych tekstów i jak możesz pomóc przy tworzeniu nowych artykułów dla danych książek. * {{lr|Zasady i wskazówki}} - zawiera podstawowe zasady etyczne postępowania w projekcie, zasady przy tworzeniu treści podręczników, wykorzystywaniu w nich zasad stylistycznych. * {{lr|Szybka pomoc}} - ci, którzy nie mają czasu czytać zaawansowanych treści pomocowych, to muszą przeczytać, tą właśnie stronę (FAQ). * {{lr|Czym jest Wikibooks}} - mówi, czym {{NS|l=tak}} jest, a czym nie jest. * {{lr|Różnice między Wikipedią i Wikibooks}} - przedstawia, czym {{NS|l=tak|k=w|w=tak}} różni się od analogicznego projektu {{NS|l=tak|w=tak}}. == Współpraca == * {{lr|Dlaczego warto rozpocząć współpracę}} - przekazuje treści dlaczego tworzyć, czy nie tworzyć właśnie na tym projekcie, do jakiego kręgu czytelników pisać tam książki. * {{lr|Dlaczego używać wolnych podręczników}} - mówi, czym się różnią wolne od niewolnych książek, czy podręczniki (treści) są zupełnie bezpłatne, czy są aktualne, czy je można je wydrukować. == Informacje == * {{lr|Dlaczego nie pisać na Wikibooks}} - mówi dlaczego nie pisać książki na {{NS|l=tak|pk=mj}}, jeżeli na tych książkach chcesz zarabiać, a nie rozpowszechniać je jako zupełnie darmowe woluminy. * {{lr2|Wikietykieta}} i {{lp2|Wikietykieta}} - mówi o etyce, jak zachowywać na projekcie, na temat ocen poszczególnych książek, nawet ich autorów. ** {{lr|Neutralny punkt widzenia}} - mówi, jak pisać książki, artykuły, aby przedstawiały neutralny punkt widzenia, aby były bezstronne. * {{lp|Żargon użytkowników}} - zawiera dialekt użytkowników projektów {{NS|l=tak|k=mw}}. * {{lr|Informacje prawne}} - informacje, jakie powinny spełniać wszystkie książki na polskim {{NS|l=tak|pk=mj}}. * {{lr|Prawa autorskie}} - zawiera treści na temat praw autorskich poszczególnych książek, jak tworzyć, aby one tego nie naruszały, co robić, gdy napotkasz to. Mówi, gdy zajdziesz w internecie treści skopiowane z polskiego {{NS|l=tak}} przypisując sobie autorstwo, to co wtedy masz robić. {{BrClear}} <noinclude>{{UnikatowaStronaKoniec}}{{Kategoria|Pomoc - Spis treści}}</noinclude> 4jbt1ocjc9pasluzoalnmm2htgyyf5p 4 62922 555685 555666 2026-09-11T13:38:30Z Persino 2851 /* Funkcja biblioteczna */ 555685 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji {{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}} lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem {{Parametr|link|tak}} zostały obtoczone znacznikiem {{Tag|code}} dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr {{Parametr|link|tak}} w szablonie {{s|NAZWASERWISU}} mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> mc5grabwf8puh6bp5ov9cowr9cvhx9c 555686 555685 2026-09-11T13:39:13Z Persino 2851 /* Funkcja biblioteczna */ 555686 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji {{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}} lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = Inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem {{Parametr|link|tak}} zostały obtoczone znacznikiem {{Tag|code}} dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr {{Parametr|link|tak}} w szablonie {{s|NAZWASERWISU}} mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> fwbo5lz1nemyzsacvgjrp8t6xz4bvjl 555694 555686 2026-09-11T14:34:29Z Persino 2851 /* Opis parametrów użytych razem z parametrem {{Code|link}} */ 555694 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji {{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}} lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = Inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem: {{Parametr|link|tak}}, zostały obtoczone znacznikiem: {{Tag|code}}, dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr {{Parametr|link|tak}} w szablonie {{s|NAZWASERWISU}} mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gokg5x0tu2wmrdgttqiq8wdtyn9exfy 555695 555694 2026-09-11T14:35:21Z Persino 2851 /* Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) */ 555695 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji {{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}} lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = Inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem: {{Parametr|link|tak}}, zostały obtoczone znacznikiem: {{Tag|code}}, dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr: {{Parametr|link|tak}}, w szablonie {{s|NAZWASERWISU}} mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr: {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie: {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> qy44hhoif5u9fmlpkrhzvqte67a94uo 555696 555695 2026-09-11T14:35:56Z Persino 2851 /* Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) */ 555696 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji {{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}} lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = Inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem: {{Parametr|link|tak}}, zostały obtoczone znacznikiem: {{Tag|code}}, dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr: {{Parametr|link|tak}}, w szablonie: {{s|NAZWASERWISU}}, mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr: {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie: {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> obu068e2yqucftu5rq2sqpdy22q3azp 555697 555696 2026-09-11T14:37:21Z Persino 2851 /* Funkcja biblioteczna */ 555697 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji {{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}} lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = Inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru: {{Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem: {{Parametr|link|tak}}, zostały obtoczone znacznikiem: {{Tag|code}}, dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr: {{Parametr|link|tak}}, w szablonie: {{s|NAZWASERWISU}}, mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr: {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie: {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> f4792qjez7949ng77hvyd2qf8z02aui 555715 555697 2026-09-11T16:12:21Z Persino 2851 /* Funkcja biblioteczna */ 555715 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji{{dk}} {{nobold|{{Code|{{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}}}}}}, lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości: {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = Inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru: {{Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem: {{Parametr|link|tak}}, zostały obtoczone znacznikiem: {{Tag|code}}, dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr: {{Parametr|link|tak}}, w szablonie: {{s|NAZWASERWISU}}, mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr: {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie: {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1fc80ghb7s15rowdis0frj7mulz6hwr 555726 555715 2026-09-11T16:54:02Z Persino 2851 /* Funkcja biblioteczna */ 555726 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == Funkcje nazw nazwy przestrzeni nazw == Należy przeczytać wiadomości ze strony {{lru|Moduły/Nazwy}}, które są informacjami wstępnymi, by używać funkcji bibliotecznych: {{m|Nazwy|Np}} i {{m|Nazwy|NpDane}}, i z nimi skojarzonych szablonów, tzn.: {{s|Np}} i {{s|NpDane}}. Wiadomosci też stąd są bardzo potrzebne do dalszych modułów tomów tej publikacji, to znaczy do funkcji, czy szablonów, nazw. === {{Code|m.Np}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|Np}}, odpowiednik funkcji, w mechanizmie '''MediaWiki''', tzn.: {{Span|styl=color:blue;|<nowiki>{{ns:<nazwa przestrzeni kanoniczna lub nie, albo jej id>}}</nowiki>}}, format tego, bo to nie jest szablon, czy funkcja, tylko wywołanie parserowe, tego, w którym jej parametr, tylko przestrzeny w nim występuje, jej element jest podobny do jej wersji bibliotecznej, opisywanej funkcji. Format wersji bibliotecznej tej funkcji jest bardzo bodobny do jej wersji szablonowej, tylko jest inne uruchomienie, tam jest ramka, a tutaj wywołanie szablonowe. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|Np}} korzysta z funkcji bibliotecznej {{m|Nazwy|Np}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|Np}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Zestaw parametrów tej funkcji są to parametry nazwane podawane, w wersji tabelkowej,, w nawiasach klamerkowej, jak się to podaje w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. ; Paramery funkcji{{dk}} {{nobold|{{Code|{{m|Nazwy|Np|...|wyspecjalizowana{{=}}tak}}}}}}, lub funkcji bibliotecznej wykorzystującej opisywaną funkcję{{Dk}} {{OpisParametrów | 1 = Parametry podstawowe | nagłówek1=tak | 2 = {{Code|nazwa}} lub {{Code|1}} | _2 = Nazwa przestrzeni nazw, kanoniczna lub nie, lub {{Code|id}} danej przestrzeni. | 3 = {{Parametr|wyspecjalizowana|tak}} | _3 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 4 = Zmienne puste lub nie, np. o wartości: {{Code|tak}}, lub nie, podawane do tej funkcji są:| nagłówek4=tak | 5 = {{Code|przedmiotowa}} | _5 = Zamienia daną przestrzeń na jej nazwę przedmiotową, tzn. na przestrzenie o numerach {{Code|id}} parzyste. | 6 = {{Code|dyskusja}} | _6 = Zamienia daną przestrzeń na jej wersję dyskusji, tzn. na przestrzenie o numerach {{Code|id}} nieparzyste. | 7 = {{Code|kanoniczna}} | _7 = Zamienia nazwę przestrzeni lub {{Code|id}} danej przestrzeni na jej nazwę kanoniczną, tzn. na jej wersję angielską. | 8 = {{Code|z myślnikami dolnymi}} | _8 = Zamienia spację w nazwach przestrzenie nazw na dolne myślniki, | 9 = {{Code|wyświetlana}} | _9 = Ten parametr nie wpływa na sposób wyświetlania nazw przestrzeni, oprócz jednej przestrzeni nazw, której jest przestrzeń główna o nazwie kanonicznej {{Code|(main)}} lub niekanonicznej {{Code|(główna)}}, wtedy są wyświetlane zamiast ciągu pustego te nazwy w zależności od podanego parametru {{Code|kanoniczna}}, tj. czy ona jest pusta lub nie, lub niepodana. | 10 = {{Code|link}} | _10 = Drukuje link o nazwie referencji, którą jest nazwa wyświetlana danej przestrzeni nazw, lub jej {{Code|id}}, o adresie strony przekierowującej, której jest adres odniesienia podanej w tabeli powyżej dla tej funkcji lub szablonu {{s|Np}}. | 11 = {{Code|id}} | _11 = wyświetla id danej przestrzeni nazw. | 12 = {{Code|nazwij projektem}} | _12 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Projekt}}. | 13 = {{Code|nazwij dyskusją projektu}} | _13 = Powoduje, że wyświetlana jest nazwa projektu {{Code|Dyskusja wikibooks}} w postaci rzeczywistej nazwy kanonicznej (używany wraz z parametrem {{Code|kanoniczna}}), tzn. w postaci nazwy {{Code|Project talk}}, lub bez tego parametru, w postaci nazwy nierzeczywistej niekanonicznej {{Code|Dyskusja projektu}}. | 14 = Inne zmienne niepuste:|nagłówek14=tak | 15 = {{Code|istnieje}} | _15 = Zwraca wartość tekstową {{Code|(bląd)}}, gdy przestrzeń jest nieprawidłowa lub nie istnieje, w innym przypadku zwraca normalną wartość. | 16 = {{Code|wynik błędu nietekstowy}} | _16 = Używany z {{Code|istnieje}}, zwraca wartość w języku {{lpg|Lua}} wartość {{Code|nil}}, gdy wartość nazwy przestrzeni nazw lub {{Code|id}} jest nieprawidłowa lub nieznana. | 17 = Zwracana zmienna w postaci tabeli ze składowymi z pewnymi podzmiennymi:|nagłówek17=tak | 18 = {{Code|uchwyt}} | _18 = Zwraca uchwyt przestrzeni nazw do danej przestrzeni nazw. }} ===== Przykłady używania ===== ====== Podstawowe wywołanie ====== Podstawowe przykłady podstawowego wywołania funkcji, czyli uzyskiwania nazwy niekanonicznej z dowolnej nazwy przestrzeni kanonicznej, czy jej numeru {{Code|id}} (kodu danej przestrzeni nazw, który reprezentuje daną przestrzeń nazw przedmiotową, czy dyskusji), a więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ [1] = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ [1] = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_3 = nazwy_modul.Np{ [1] = 10, }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Szablon", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "Template", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_6 = nazwy_modul.Np{ nazwa = 10, }; </syntaxhighlight> Te trzy pary wywołania wyświetlają ten sam wynik tzn. o takiej samej wartości, bo parametr {{Code|nazwa}} wskazuje na tą samą przestrzeń nazw, tylko one są rożnie wskazane. Został ta użyty parametr: {{Code|1}} lub {{Code|nazwa}}, które oznaczają to samo, czyli przestrzeń nazw w postaci kanonicznej, niekanonicznej, czy numeru {{Code|id}}, czyli identyfikatora przestrzeni nazw. Jako wartość uzyskujemy tam nazwę kanoniczną przestrzenina polskiem {{NS|l=tak|p=ie}}. Przestrzeń nazw może zawierać dowolnej wielkości litery, z dowolną liczbą odstępów z dolnymi spacjami lub normalnymi, jeżeli w nim one występują,wtedy zawsze oznaczają one tą samą przestrzeń, niezależnie jak ją zapiszemy, przykłady poniżej. Równie dobrze dowolną nazwę niekanoniczną możemy napisać, co jest uwidocznione w parametrze {{Code|nazwa}}, na wyjściu otrzymujemy w pełni sformatowaną nazwę niekanoniczną, która odpowiada jej odpowiednikowi niesformatowanemu: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "SZABLON", }; -- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "TEMPLATE", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "DYSKUSJA ___ ___ _ SZABLONU", }; -- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "TEMPLATE_________TALK", }; </syntaxhighlight> ====== Nazwy kanoniczne i niekanoniczna oraz zamiana z jednej na drugą ====== Aby uzyskać nazwę z dowolnej nazwy, nawet też kanonicznej, czynie, czy też z numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy należy podać parametr przestrzeni nazw, z dodatkowym parametrem {{Code|kanoniczna}}, w takim razie: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_1 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_2 = nazwy_modul.Np{ nazwa = "Template", kanoniczna = "tak", }; -- Uzyskujemy wartość: "Template": local nazwa_kanoniczna_3 = nazwy_modul.Np{ nazwa = 10, kanoniczna = "tak", }; </syntaxhighlight> * Według powyższego przykładu, ona, czyli przestrzeń nazw, jest zamieniana na sformatowaną nazwę kanoniczną, jako parametr może być nazwa niekanoniczna, kanoniczna, czy identyfikator przestrzeni nazw. Dowolną nazwę kanoniczną, czy nie, można zamienić na niekanoniczną, niezależnie w jakiej formie podamy przestrzeń nazw, może być to przekształcenie tożsamościowe, może być to w postaci identyfikatora tej przestrzeni, niezależnie jaką ją mamy na myśli, więc: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Uzyskujemy wartość: "Szablon": local nazwa_niekanoniczna = nazwy_modul.Np{ nazwa = "Template", }; </syntaxhighlight> * Wystarczy wtedy użyć tylko jednego parametru, nie trzeba używać większej liczby innych parametrów. ====== Nazwy przedmiotowe i dyskusji oraz przejścia pomiędzy nimi ====== Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzoną, tzn. z przedmiotowej do dyskusji lub odwrotnie, przykłady poniżej. Do tego celu używamy parametru {{Code|przedmiotowa}}, czyli do tłumaczenia nazwy przestrzeni nazw na jej wersję przedmiotową, tzn. na przestrzeń nazw o identyfikatorze parzystym. Można też użyć parametru {{Code|dyskusja}}, robiąca tłumaczenia na wersje dyskusji, o identyfikatorze nazwy przestrzeni nazw nieparzystym. Nie wolno używać tych parametrów, tych dwóch w jednym wywołaniu, bo może dojść do błędu funkcji w postaci komunikatu {{Code|(błąd)}}. Tłumaczona nazwa może być zarówno niekanoniczna, jak i kanoniczna, lub być zawarta w postaci identyfikatora przestrzeni nazw. Tutaj bez użycia żadnego parametru dodatkowego, wtedy otrzymujemy na wyjściu nazwę niekanoniczną. <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", }; -- Gdy prrzestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", }; ---- Zwraca wartość: szablon "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, zamieniający dowolne przestrzenie nazw, niezależnie, czy jest zapisana w postaci identyfikatora, czy nie, gdy nazwą przestrzeni jest nazwa niekanoniczna (lub kanoniczna), to uzyskana nazwa przedmiotowa, czy dyskusji, jest nazwą kanoniczną, jako w wyniku: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać, gdy nazwę przedmiotową tłumaczymy na przedmiotową, dyskusji na dyskusji, wtedy tłumaczenie z przestrzeni do przestrzeni jest tożsamościowe, niezależnie w jakiej formie podamy nazwę przestrzeni nazw jako parametr, tłumaczymy nazwę polską na tą samą nazwę też polską, o tej samej wartości lub jej odpowiednik angielski w wersji kanonicznej na jej wersję niekanoniczną, czy z numeru identyfikatorana jej odpowiednik nazwowy, ale nadal takie przejście jest tożsamosciowe, bo chodzi o tą samą przestrzeń nazw, mimo że użyliśmy tych parametrów: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak",}; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak",}; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak",}; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, to uzyskana nazwa przedmiotowa, czy dyskusji, wtedy mamy tłumaczenie tozsamościowe, jeśli chodzi o przestrzeń nazw, co one oznaczają, jeśli ona jest niekanoniczna, to uzyskamy jej nazwę, ale po angielsku, a jeśli jednak jest kanoniczna, to otrzymamy ten sam wynik: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.Np{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.Np{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.Np{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", }; -- Gdy przestrzeń nazw jest w postaci numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.Np{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.Np{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Nazwy przestrzeni z myślnikami dolnymi ====== Gdy używamy przestrzeni nazw, czy to w postaci kanonicznej, czy niekanonicznej, ze spacjami, to spacje są w nim zamieniane na dolne myślniki. Jeżeli parametr zawiera spacje lub dolne myślniki na końcach nazwy, to ona jest trimowana, wewnątrz, wtedy powtórzone spacje, lub myślniki dolne, są zamieniane na jeden dolny myślnik, jeżeli zamieniamy nazwę niekanoniczną na niekanoniczną, kanoniczną na kanoniczną. Gdy tak nie jest, tzn. gdy zamieniamy kanoniczną na niekanoniczną, niekanoniczną na kanoniczną, to wtedy jest podobnie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przestrzeni nazw ====== Gdy nazwą przestrzeni nazw jest nazwa o charakterze niepustym, to przy parametrze {{Code|wyświetlana {{=}} "tak"}}, jest zamieniana ona na tą samą nazwę, gdy ona jest pusta, to jest zamieniana na szereg: {{Code|(główna)}} bez parametru {{Code|kanoniczna}}, a z tym parametrem na {{Code|(main)}}. Przykłady jak jest, jest powiedziane: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_1 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_2 = nazwy_modul.Np{ nazwa = "Szablon", wyświetlana = "tak", }; ---- Zwraca wartość: "": local nazwa_przestrzeni_3 = nazwy_modul.Np{ nazwa = "", wyświetlana = "", }; ---- Zwraca wartość: "(główna)": local nazwa_przestrzeni_4 = nazwy_modul.Np{ nazwa = "", wyświetlana = "tak", }; ---- Zwraca wartość: "(main)": local nazwa_przestrzeni_5 = nazwy_modul.Np{ nazwa = "", kanoniczna = "tak", wyświetlana = " tak", }; </syntaxhighlight> Na podstawie ramki powyżej w przestrzeniach nazw wyświetlanych dowiadujemy się, że jedyna różnica, w nazwach wyświetlanych lub nie, jest dla przestrzeni głównej, czyli dla przestrzeni nazw, której nazwa przestrzeni jest ciągiem pustym. ====== Wersja funkcji z wyświetlaną nazwą przestrzeni nazw z linkiem opisującej tą przestrzeń ====== Nazwę przestrzeni nazw zamieniamy na link z opisem, co robi dana przestrzeń nazw, z nazwą wyświetlaną niekanoniczną, bez parametru {{Code|kanoniczna}}, lub z tym,wtedy nazwę wyświetlaną jest kanoniczna. Gdy przestrzeń nazw jest główna, to wtedy nazwą linku jest {{Code|(główna)}} ({{Code|(main)}} z parametrem {{Code|kanoniczna}}). <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "", link = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "", link = "tak", kanoniczna = "tak", }; </syntaxhighlight> Przykłady funkcji w wyniku są w przykładach szablonowych: # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}Szablon|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=Szablon|link=tak|kanoniczna=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak}}}} # {{Code|{{s|Np|nazwa{{=}}|link{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{Np|nazwa=|link=tak|kanoniczna=tak}}}} ====== Uzyskiwanie numeru {{Code|id}} danej przestrzeni nazw ====== Gdy chcemy uzyskać numer identyfikatora przestrzeni nazw, czy to z użyciem parametru {{Code|kanoniczna}}, czy nie, wtedy ten parametr jest w tym przypadku ignorowany, przy parametrze {{Code|id {{=}} "tak"}} na jej odpowiednik w postaci numeru, który charakteryzuje przestrzenie przedmiotowe i dyskusji, inna jest dla tych dwóch typów przestrzeni. Dla przestrzeni przedmiotowej {{Code|id}} jest parzyste, a dla dyskusji nieparzyste. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_1 = nazwy_modul.Np{ nazwa = "Szablon", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 10: local id_2 = nazwy_modul.Np{ nazwa = "Szablon", kanoniczna = "tak", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_3 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", id = "tak", }; ---- Uzyskany numer id nazwy przestrzeni nazw jest 11: local id_4 = nazwy_modul.Np{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", id = "tak", }; </syntaxhighlight> ====== Uzyskiwanie nazwy projektu nazwy przedmiotowej i jej dyskusji, z kanonicznej lub nie, przestrzeni nazw ====== Gdy używamy przestrzeni nazw {{Np|Wikibooks|link=tak}} lub {{Np|Wikibooks|link=tak|dyskusja=tak}}, to je można tłumaczyć na je wersje czysto kanoniczne, tzn.: {{Np|Wikibooks|link=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak}}, gdy translacja jest na nazwę polską niekanoniczną, a gdy użyjemy parametru {{Code|kanoniczna}}, wtedy sytuacja jest inna: {{Np|Wikibooks|link=tak|kanoniczna=tak}} tłumaczymy na {{Np|Wikibooks|link=tak|nazwij projektem=tak|kanoniczna=tak}}, a {{Np|Wikibooks|link=tak|dyskusja=tak|kanoniczna=tak}} na {{Np|Wikibooks|link=tak|dyskusja=tak|nazwij dyskusją projektu=tak|kanoniczna=tak}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Projekt": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij projektem"] = "tak", kanoniczna = "tak", }; ---- Zwraca wartość: "Dyskusja projektu": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_4 = nazwy_modul.Np{ nazwa = "Wikibooks", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", }; </syntaxhighlight> ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Gdy używamy przestrzeni nieistniejącej bez parametru {{Code|istnieje {{=}} "tak" }}, wtedy na wyjściu otrzymamy to samo, tylko w wersji sformatowanej, a gdy użyjemy, wtedy pojawia tam się napis {{Code|(błąd)}}. Gdy parametrem jest znana funkcji przestrzeń nazw, to nie uzyskujemy błędu, tylko przepisaną sformatowaną nazwę. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", }; </syntaxhighlight> ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Gdy oprócz parametru {{Code|istnieje {{=}} "tak"}}, użyjemy {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, wtedy dla nieznanej przestrzeni uzyskujemy wartość w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: {{Code|nil}}, a w wikikodzie natomiast uzyskujemy wartość pustą, co pomaga w sprawdzeniu, czy dana przestrzeń istnieje, ale dodatkowo trzeba użyć parametru {{Code|["wyświetlana"] {{=}} "tak"}}, by nie pomylić parametru błędu z przestrzenią główną, wtedy ta przestrzeń ma nazwę niepustą przy tych parametrach, bo wtedy mamy nazwę niekanoniczną {{Code|(główna)}}, kanoniczną, przy specjalnym parametrze, czyli: {{Code|(main)}}, wtedy możemy użyć parsera {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.Np{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.Np{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", }; </syntaxhighlight> ====== Uzyskiwanie uchwytu danej przestrzeni nazw analogicznie do funkcji {{LzLua|mw.site.namespaces}} ====== Uchwyt niskopoziomowy do danej przestrzeni nazw można uzyskać przy pomocy kodu, uzyskujemy dla tej tablicy przestrzennej, która jest połączona z metatabelką, dzięki której możemy podawać przestrzenie nazw w wersji niezależnie jakimi literami, z dowolną kliczbą odstępów, nawet zapisana dolnymi myślnikami: <syntaxhighlight lang="lua"> local uchwyt_1 = mw.site.namespaces["Szablon"]; local uchwyt_2 = mw.site.namespaces["Template"]; local uchwyt_3 = mw.site.namespaces[10]; </syntaxhighlight> Funkcja powyżej ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To samo, ale wysokopoziomowe, można utworzyć przy pomocy parametru: {{Code|uchwyt}}, wtedy szablon z rzuci odwołanie do tej tabeli, ale nie zawsze tak jest, czasami, gdy jakieś przestrzenie nie istnieją na polskim {{NS|w=tak|l=tak|pk=mj}}, wtedy odwołujemy się do jej wersji pseudo tej tabeli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.Np{ nazwa = "Szablon", uchwyt = "tak", }; local uchwyt_2 = nazwy_modul.Np{ nazwa = "Template", uchwyt = "tak", }; local uchwyt_3 = nazwy_modul.Np{ nazwa = 10, uchwyt = "tak", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.Np}} jest bardziej ogólniejsza niż {{LzLua|mw.site.namespaces}}, ponieważ uwzględnia większą liczbę nazw przestrzeni nazw, bo ona uwzględnia nieznane przestrzenie i znane o nieznanych nazwach, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. === {{Code|m.NpDane}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NpDane}}. Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. * Szablon {{s|NpDane}} korzysta z funkcji bibliotecznej {{m|Nazwy|NpDane}}, więc parametry obu są wręcz takie same, a nawet podobne. Chociaż ta sama nazwa funkcji w ramce i kodzie {{lpg|Lua}}, to używanie ich nie jest dokładnie takie samo, funkcja biblioteczna nie potrzebuje parametru {{Parametr|wyspecjalizowana|tak}}, a ramka już tak, a szablon {{s|NpDane}}, który korzysta z tej ramki, to nieobecność, lub obecność z wartością pustą, tego parametru powoduje, że przyjmowane są parametry rodzica, a nie dziecka, które wymagają jego niepustość. ==== Funkcja biblioteczna ==== Szablon służy przede wszystkim do tłumaczenia angielskich nazw przestrzeni nazw na ich wersję w jakimś języku i operacji odwrotnej, a także numer przestrzeni nazw na jej nazwę w nim angielską lub w jakimś języku, lub odwrotnie, umożliwia też na przetłumaczenie nazwy przestrzeni nazw lub identyfikatora przestrzeni na jej nazwę polską, jeżeli istnieje. Funkcja {{m|Nazwy|NpDane}} przyjmuje te same parametry, co {{m|Nazwy|Np}}, oprócz wywołania ramkowego: {{Code|uchwyt}} (która w tej funkcji w sposób inny jest zdefiniowana, nie jak w funkcji: {{m|Nazwy|Np}}), jak oba, którego tutaj w nim nie ma, a jako zwykła funkcja biblioteczna może przyjmować ten parametr. Te zmienne działają podobnie w obu procedurach, z tą różnicą, że mamy inny zestaw nazw przestrzeni nazw (czasami bez numerów {{Code|id}} - identyfikatorów tych obsługiwanych przestrzeni nazw, a te podstawowe one je mają, jeżeli da się je powiązać z pierwszą funkcją w drugiej, jedynie w takim przypadku one występują) i można też użyć parametrów dodatkowych, które są niedostępne w pierwszej funkcji, a w drugiej już tak. Dodatkowo on przyjmuje argumenty: {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = Kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru: {{Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} ===== Używanie kluczy projektu, kodów projektu i kodów języka ===== Kody nazw piszemy, jak zwykle, z małej litery, co jest zalecane, ale można je pisać z liter o dowolnej wielkości. ====== Użycie różnych kodów i ich równoważność ====== Kody projektu i języka możemy pisać ze względu na dwa sposoby, w zależności jakich zmiennych używamy, możemy pisać tzw. grupę tych kodów w jednej zmiennej, wtedy się liczy ostateczny adres do danego projektu w jakieś wersji językowej, tylko jeden, a nie n-wersji danego języka i m-wersji danego projektu, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "en:de:w:ru:en:q:pt", ... }; </syntaxhighlight> * Najważniejsze są kody projektu końcowe, podobnie ma się sprawa z kodami języków, tutaj kodami projektów są: {{Code|w}} ({{NS|l=tak|k=w}}) i {{Code|q}} ({{NS|l=tak|k=q}}), a kodami języków są: {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}), {{Code|de}} ({{lpg|{{#invoke:lang|hasło|de}}}}), {{Code|ru}} ({{lpg|{{#invoke:lang|hasło|ru}}}}), {{Code|en}} ({{lpg|{{#invoke:lang|hasło|en}}}}) i {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}), czy końcowy kod projektu jest: {{Code|q}} ({{NS|l=tak|k=q}}) i kod języka {{Code|pt}} ({{lpg|{{#invoke:lang|hasło|pt}}}}). W powyższym przykładzie napisaliśmy mnóstwo kodów w postaci jednej zmiennej, to jest równoważne zapisowi, czyli ostatecznej wersji wspomnianej powyższego zapisu, też zapisaną za pomocą tej samej zmiennej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik_1 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "pt:q", ... }; local wynik_2 = nazwy_modul.NpDane{ ..., ["klucz projektu"] = "q:pt", ... }; </syntaxhighlight> Powyższy wynik rozpisujemy na dwie zmienne, w których podajemy tylko pojedyncze kody, a nie grupy, więc widziemy, ża zamiast podawania jednego parametru z interwiki, to możemy to rozbić na dwa parametry kodu projektu i języka, a nie używać to w jednej zmiennej, należy pamiętać, że w tych kodach, może być jedno interwiki, specjalnie dla projektu lub języka, do którego dana zmienna jest przystosowana: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local wynik = nazwy_modul.NpDane{ ..., ["kod projektu"] = "q", ["kod języka"] = "pt", ... }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni głównej ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''głównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, wtedy uzyskujemy niezależnie od projektu wartość pustą, bo takie jest przedstawienie wartości niewyświetlanej przestrzeni głównej na każdym projekcie obsługujący przestrzenie nazw, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, wtedy uzyskujemy na wyjściu to samo, co powyżej, czyli wartość pustą, bo wartość {{Code|0}} jest odpowiednikiem przestrzeni głównej, czyli poniższe przykłady są odpowiedniami tych powyższych, czyli te dwa przykład, tak można powiedzieć, że to samo robią: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi pustemu: "": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", }; </syntaxhighlight> 0 Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, wtedy jeżeli nie ma wartości kanonicznej dla danego języka projektu, to wyswietlana jest wartość {{Np|(main)|link=tak|kanoniczna=tak}}, a dla polskigo projektu {{Np|(main)|link=tak}}, a dla innych języków jest nazwa charakterystyczna dla danego języka pod warunkiem, jeżeli doda się tego obsługę, więc tego przykłady przy użyciu zmiennej {{Code|["wyświetlana"] {{=}} "tak"}}, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw przestrzeni głównej, w takim przypadku uzyskujemy to samo co powyżej, tylko jest inaczej, oznaczana jest wtedy przestrzeń główna, dla tego samego projektu siostrzanego, w wersji charakterystycznej dla danego języka, tutaj dla angielskiego: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(main)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni głównej ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące się ciągiem niepustym mamy podobne wyniki, jak powyżej bez parametry {{Code|["wyświetlana"] {{=}} "tak"}}, tylko nazwa wyświetlana przestrzeni nazw jest po polsku (odpowiednia nazwa w języku polskim), a nie po angielsku (w języku danego projektu): Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej, nazw przestrzeni nazw mający nazwy puste, ale zamienione na nazwy wyświetlane, ale w postaci języka polskiego, używając parametru {{Code|["po polsku"] {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu identyfikatora przestrzeni nazw głównej, czyli dla tej samej przestrzeni nazw, co powyżej, tylko ona jest inaczej oznaczana, to możemy zrobić to samo, co powyżej, tylko nazwa główna przestrzeni nazw jest inaczej zapisana, w postaci numerycznej, wtedy otrzymamy wynik taki sam, jak w powyższym przykładzie, bo w obu używaliśmy takiej samej przestrzeni, tylko różnie przepisaną: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 0, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość nazwy przestrzeni głównej: "(główna)": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 0, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> ====== Nazwy wyświetlane przy użyciu tych kodów dla przestrzeni innej niż główna ====== Nazwy bez użycia zmiennej powodujące wyświetlanie nazwy przestrzeni nazw '''niegłównej''' na różnych projektach w postaci nieprzetłumaczonej na język polski, tylko w wersji charakterystucznej dla języka danego projektu używaną w odwołaniu: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", }; </syntaxhighlight> A przy zamianie tej przestrzeni nazw w powyższym przykładzie na numer - identyfikator nazw, czyli {{Code|id}}, to identyfikator przestrzeni nazw, innej niż główna, z jej wersji nazwowej, otrzymamy wynik w postaci nazwy niepustej, bo to nie jest przestrzeń główna, oznaczana zerowy tym identyfikatorem, czyli w postaci tej liczby: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", }; ---- Zwraca wartość równą ciągowi niepustemu: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie w postaci znaków, o charakterze niepustości, przy użyciu tego parametru, otrzymujemy wynik, jak powyżej, bo nazwa wyświetlana przestrzeni jest od razu niepusta, bo przestrzeni nazw mają wartość niepustą, więc nie trzeba ich uznawać, że są inne: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> A gdy parametr {{Code|nazwa}} przyjmuje wartość liczbową w postaci identyfikatora {{Code|id}}, innej niż dla przestrzeni głównej, ale zapisaną dla tych samych przestrzeni nazw, jak powyżej, co czyni, że tutaj jest też podobnie, otzrymamy te same wartości, tylko jest inna reprezentacja parametrów wchodzących do funkcji, jak powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla przestrzeni niepustej, że użycie tego parametru, według przykładów powyżej, jest opcjonalne, a nawet zbędne, bo ten parametr w tym przypadku nic nie zmienia, zmienia tylko dla przestrzeni głównej, którego ciąg charakteryzujący tą przestrzeń jest pusty, a jej wersja wyświetlana posiada za to ciąg niepusty, o jej wersji kanonicznej {{Code|{{Np|(main)|link=tak|kanoniczna=tak}}}}, a w wersji polskiej {{Code|{{Np|(main)|link=tak}}}}, te nazwy można pomiędzy sobą tłumaczyć za pomocą funkcji {{m|Nazwy|NpDane}} lub szablonu {{s|NpDane}}. ====== Nazwy wyświetlane przy użyciu tych kodów przetłumaczone je na język polski dla przestrzeni innej niż główna ====== Z wyświetlaniem na ekranie przestrzeni nazw charakteryzujące ciągiem niepustym mamy podobne wyniki jak powyżej bez parametru {{Code|["wyświetlana"] {{=}} "tak"}}: Przy użyciu zmiennej generującej wyświetlanie w postaci znaków o charakterze niepustej przetłumaczonej na język polski, używając parametrów w postaci pewnych nazw niepusstych, dla projektów innych niż wq języku polskim, ale te przestrzenie nazw tłumaczymyna ich odpowiedniki polskie, jakie istnieją, na projektach właśnie, że polskich: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Albo przy użyciu numeru {{Code|id}} (identyfikatora przestrzeni nazw), wtedy właśnie robimy to samo, co powyżej, tylko jest inna reprezentacja parametrów, ale ta sama przestrzeń, więc uzyskujemy te same wyniki, czyli o tej samej wartości, mimo, że wizulanie,a by inne parametry: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["po polsku"] = "tak", }; </syntaxhighlight> Przy użyciu zmiennej generującej wyświetlanie, użzywając parametru wspoianego powyżej, w postaci znaków o charakterze niepustej przy użyciu tego parametru, co sugeruje, że ten argiment nic nie zmienia, ale jedynie wyświetla się to samo, co bez tego parametru: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> A tutaj przy użyciu identyfikatora przestrzeni nazw przestrzeni nazw niegłównej, czyli przestrzeni nazw charakteryzującej się jej wersją niewyświetlaną niepustą, z tymi samymi parametrami, co powyżej, z tymi samymi wartościami, tylko jest inna reprezentacja przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; ---- Zwraca wartość równą nazwie przestrzeni niegłównej: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "commons", ["wyświetlana"] = "tak", ["po polsku"] = "tak", }; </syntaxhighlight> Widzimy, jedynie dla tej przestrzeni, że użycie wspomnianego tego parametru jest opcjonalne, bo nic w tym przypadki nie zmienia, bo przestrzeń nazw nie jest pusta, lub nie jest reprezentowana inaczej, niż przez liczbę {{Code|0}}. ===== Tłumaczenie nazw przestrzeni nazw z jednego języka na drugi ===== ====== Tłumaczenie nazw obcojęzycznych nazw przestrzeni nazw na jej wersję polską, tzn. jej język polski, i na język angielski, tzn. jej wersje angielską w postaci nazwy kanonicznej, albo identyfikator przestrzeni nazw lub operację przeciwną ====== Tłumaczenie na nazwę kanoniczną w języku angielskim, z nazwy polskiej, czy nazwy w innym języku, tutaj w języku polskim, w jakim ona jest jedynie dostępna, przy użyciu parametru {{Code|kanoniczna {{=}} "tak"}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Tłumaczenie identyfikatora przestrzeni nazw na nazwę kanoniczną, ale przestrzeni nazw są te same, co powyżej, tylko zamiast przestrzeni nazw: "Szablon", mamy to jej idenntyfiator, którym jest liczba: {{Code|10}}, wtedy otrzymamy te same wyniki, co powyżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", kanoniczna = "tak", }; ---- Zwraca wartość: "Template": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", kanoniczna = "tak", }; </syntaxhighlight> Przypadek odwrotny, do poprzednich, dla tego samego projektu, gdy nie używamy tego parametru, ale przestrzenie nazw są tym razem po angielsku, jako nazwy kanoniczne, które są zamieniane na jej wersją charakterystyczną dla danego projektu, tutaj polską: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Template", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Template", ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> Identyfikator przestrzeni nazw tłumaczymy na jego nazwę polską - ewentualnie, na wersję języka projektu, i dlatego tutaj używamy języka polskiego, ponieważ mamy do czynienia z projektem polskojęzycznym, bo kod języka projektu wskazuje tutaj na ten język: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, ["kod projektu"] = "w", ["kod języka"] = "pl", }; </syntaxhighlight> ====== Tłumaczenie nazw przestrzeni na jej wersję w innych języku w jakikolwiek projekcie ====== Do tłumaczenia używamy parametru {{Code|awaryjnie}}, której użycie w funkcji {{m|Nazwy|NpDane}}, powoduje skorzystanie z bazy danym projektów {{Code|MediaWiki}}, czyli {{Code|{{NS|l=tak|w=tak|k=en:d|jw=tak}}}} (po angielsku), a inaczej {{Code|{{NS|l=tak|w=tak|k=d}}}} (po polsku): * Przy użyciu nazw przestrzeni nazw w postaci, nie identyfikatorów, nazwanej łańcuchem znaków,możemy daną przestrzeń przetłomaczyć na dany język, nie używając przy tym żadnych stron: {{Code|.json}}, w podstronach modułu {{Code|{{m|Nazwy/}}}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Kategorie", ["klucz projektu"] = "de:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Категория", ["klucz projektu"] = "ru:w", awaryjnie = "tak", kanoniczna = "tak", }; local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Category", ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> * Jako z ich wersją numeryczną, czyli w postaci identyfikatorów, nazwanej w postaci pewnego numeru, ale przestrzenie nazw są te same, co powyżej, tylko inaczej zapisane, a inne parametry są takie same, czyli z czterech przykładów generują się jedynie dwa, ale wyniki są te same: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 14, ["klucz projektu"] = "de:w", awaryjnie = "tak", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa 14, ["klucz projektu"] = "ru:w", awaryjnie = "tak", }; </syntaxhighlight> Przykłady tłumaczenia z jednej wersji językowej w danym języku na angielski (wersję kanoniczną) i odwrotnie # {{Code|{{s|NpDane|Kategorie|klucz projektu{{=}}de:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Kategorie|klucz projektu=de:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|Категория|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|Категория|klucz projektu=ru:w|awaryjnie=tak|kanoniczna=tak}}}} # {{Code|{{s|NpDane|Category|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} Przykłady przy użyciu identyfikatorów: # {{Code|{{s|NpDane|14|klucz projektu{{=}}de:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=de:w|awaryjnie=tak}}}} # {{Code|{{s|NpDane|14|klucz projektu{{=}}ru:w|awaryjnie{{=}}tak}}}} → {{Tt|{{NpDane|Category|klucz projektu=ru:w|awaryjnie=tak}}}} ===== Użycie parametru {{Code|link}} oraz zależność od projektu i języka, wyświetlanie nazw przestrzeni nazw po polsku ===== Przykłady poniżej i niektóre wywołania funkcji {{m|Nazwy|NpDane}} piszemy przy pomocy parametru {{Code|link}}, który posiłkujemy z {{Code|klucz projektu}}, przykładowo z pomożeniem użycia zmiennej {{Code|po polsku}}, ewentualnie z użyciem argumentu {{Code|kanoniczna}}, co powoduje wyświetlanie się linku do pewnej strony naa tym samym projekcie lub innym,a jeśli mamy nazwę kanoniczną, to otrzymamy w linku nazwę linku właśnie że wyświetlaną, np. w postaci: {{Np|(main)|link=tak}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Szablon", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Template", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = "", link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = "", link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> Teraz będziemy, to robili przy użyciu identyfikatorów przestrzeni nazw, który będziemy tłumaczyć na jego wersję charakterystyczną dla danego projektu, nazwę kanoniczną lub na jego odpowiednik polski, ale mamy te same przykłady, co powyżej, bo te same przestrzenie nazw, tylko z tą różnicą, że ona jest inaczej zapisana, więc otrzymamy te same wyniki, więc: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = 10, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", }; local nazwa_przestrzeni_nazw_7 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; ---- Tutaj nazwa przestrzeni zostanie wyświetlona, jako nazwa linku, po angielsku, czyli w wersji kanonicznej local nazwa_przestrzeni_nazw_8 = nazwy_modul.NpDane{ nazwa = 0, link = "tak", kanoniczna = "tak", ["klucz projektu"] = "en:w", ["po polsku"] = "tak", }; </syntaxhighlight> ---- Przykłady funkcji w wyniku są: # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}Szablon|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Szablon|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki tych samych przykładów, co powyżej, tylko przestrzeń nazw jest w postaci numerycznej: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}pl:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- Inne przykłady, projektu niepolskiego, ale mającej jego wersje polską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, odpowiedniki przykładów powyższych z innym przedstawieniem przestrzeni nazw: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=en:w|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=en:w|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}en:w|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=pl:w|kanoniczna=tak}}}} ---- ---- A dla projektu niemającej wersji polskiej, np. tylko wersję angielską: # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}Template|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=Template|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=|link=tak|klucz projektu=commons|kanoniczna=tak}}}} Gdy parametr {{Code|nazwa}} jest liczbą, wtedy mamy te same przykłady, co powyżej, tylko ta sama przestrzeń nazw jest w innej postaci przedstawiona: # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}10|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=10|link=tak|klucz projektu=commons|kanoniczna=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|po polsku{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|po polsku=tak}}}} # {{Code|{{s|NpDane|nazwa{{=}}0|link{{=}}tak|klucz projektu{{=}}commons|kanoniczna{{=}}tak}}}} → {{Tt|{{NpDane|nazwa=0|link=tak|klucz projektu=commons|kanoniczna=tak}}}} ===== Zamiana przestrzeni nazw przedmiotowej na dyskusji lub przeciwnie, i transformacje tożsame ===== * Używać tu będziemy dodatkowo parametrów: {{Code|przedmiotowa}} - zamiany przestrzeni nazw na przedmiotową, czy: {{Code|dyskusja}} - na dyskusji. Można też przechodzić z tej samej przestrzeni nazw w nią samą, lub do niego skojarzonej, tzn. z przedmiotowej do dyskusji lub odwrotnie, wtedy w tym przypadku otrzymujemy nazwę po polsku, dla poskich projektów, dla projektów w danym języku, na nazwę w danym języku, przykłady: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwa kanoniczna ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy prrzestrzeń nazw jest w postaci jej numeru id ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, wtedy otrzymujemy te nazwy w postaci nazwy w języku angielskim (kanoniczne) tych przestrzeni nazw, są te same przykłady, co powyżej, tylko jest inna wersja językowa w wyniku tej samej otrzymanej przestrzeni nazw: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Szablon", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", -- Gdy nazwą przestrzeni jest nazwa kanoniczna: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template talk", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: ""Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 11, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 10, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Przejście z tej samej przestrzeni na tą samą możemy uzyskać to wtedy, tzw. przejście tożsamościowe, poprzez tłumaczenie nazw dyskusji na dysusji, i nazw przedmiotowych na przedmiotowe, dla róznych projektów, nie tylko polskich, a tutaj mamy dla języka polskiego, tylko repezentacja językowa może być inna, tutaj jest ta polska (w wersji niekanonicznej) i angielska (w wersji kanonicznej): <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwa niekanoniczna, gdy w ty przypadku chcemy uzyskać nazwę charakterystyczną dla danego języka danego projektu: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja szablonu": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy użyjemy dodatkowo parametr {{Code|kanoniczna}}, uzyskamy nazwę angielską danej przestrzeni nazw, nawet gdy to jest przestrzeń podana w języku polskim, dla polskiego projektu, lub w jezyku charakterystycznym dla danego projektu, jeżeli mamy to w bazie przestrzeni nazw w formie pliku {{Code|.json}}, podane w podstronach modułu {{m|Nazwy/}}, to te nazwy wtedy obsługuje: <syntaxhighlight lang="lua"> local nazwy_modul = require("Module:Nazwy"); -- Gdy nazwą przestrzeni jest nazwą niekanoniczną: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_1 = nazwy_modul.NpDane{ nazwa = "Szablon", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy nazwą przestrzeni jest nazwą kanoniczną: ---- Zwraca wartość: Template": local nazwa_przestrzeni_przedmotowej_2 = nazwy_modul.NpDane{ nazwa = "Template", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_2 = nazwy_modul.NpDane{ nazwa = "Template talk", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; -- Gdy przestrzeń nazw jest w postaci jej numeru id: ---- Zwraca wartość: "Template": local nazwa_przestrzeni_przedmotowej_3 = nazwy_modul.NpDane{ nazwa = 10, przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", } ---- Zwraca wartość: "Template talk": local nazwa_przestrzeni_dyskusji_3 = nazwy_modul.NpDane{ nazwa = 11, dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Nazwy przestrzeni z myślnikami dolnymi ===== Jeżeli nazwy danych przestrzeni, niezależnie, czy są w postaci niekanonicznej, czy nie, ale jeżeli w nazwie zawierają spację, to one jako w wyniku zamiast nich będą miały dolny myślnik zamiast spacji, gdy użyjemy parametru: {{Code|["z myślnikami dolnymi"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_1 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja_szablonu": local nazwa_przestrzeni_2 = nazwy_modul.NpDane{ nazwa = "Template talk", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk";: local nazwa_przestrzeni_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja szablonu", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Template_talk": local nazwa_przestrzeni_4 = nazwy_modul.NpDane{ nazwa = "Template talk", kanoniczna = "tak", ["z myślnikami dolnymi"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Uzyskiwanie kanonicznej nazwy projektu, nazwy przedmiotowej i jej dyskusji, z jej odpowiednika nazwy przestrzeni nazw ===== Dla przestrzeni nazw: {{NpDane|Wikipedia|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia|link=tak|kanoniczna=tak|nazwij projektem=tak|klucz projektu=pl:w}} możemy uzyskać, gdy dla funkcji {{m|Nazwy|NpDane}} podamy parametr: {{Code|["nazwij projektem"] {{=}} "tak"}}, dla przestrzeni przedmiotowej lub dyskusji: {{NpDane|Wikipedia talk|link=tak|klucz projektu=pl:w}}, jej nazwy projektowej: {{NpDane|Wikipedia talk|link=tak|kanoniczna=tak|nazwij dyskusją projektu=tak|klucz projektu=pl:w}}, gdy podamy parametr {{Code|["nazwij dyskusją projektu"] {{=}} "tak"}}, czyli: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Wikipedia": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij projektem"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij projektem"] = "tak", przedmiotowa = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Dyskusja Wikipedii": local nazwa_przestrzeni_nazw_4 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_5 = nazwy_modul.NpDane{ nazwa = "Dyskusja Wikipedii", ["nazwij dyskusją projektu"] = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Project talk": local nazwa_przestrzeni_nazw_6 = nazwy_modul.NpDane{ nazwa = "Wikipedia", ["nazwij dyskusją projektu"] = "tak", dyskusja = "tak", kanoniczna = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> ===== Różne wersje sprawdzania istnienia przestrzeni nazw ===== ====== Sprawdzanie, czy dana przestrzeń jest poprawnie podane, czy istnieje ====== Możemy sprawdzić, istnienie podanej przestrzeni nazw poprzez użycie parametru {{Code|istnieje}} z wartością niepustą, wtedy dla obu jej wartości uzyskujemy wyniki, wskazujać, czy istnieją przestrzenie nazw istniejące i które nie mają prawa istnieć z racji bytu, w pierwszym przypadku otrzymamy treściwy wynik, a w drugim komunikatro błędzie: <syntaxhighlight lang="lua">0 local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "(błąd)": local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Gdy dana przestrzeń nie istnieje przy użyciu wartości niepustej parametru {{Code|istnieje}}, wtedy otrzymujemy błąd funkcji w postaci tekstu {{Code|(błąd)}}, a gdy nie podamy tego parametru, to otrzymamy nazwę sformatowaną danej nieznanej przestrzeni nazw po usunięciu wszystkich spacji lub dolnych myślników na początku i końcu ciągu oraz zbędnych wewnątrz tego ciągu i zastąpieniu ich kolejnych jedną spacją. A gdy jednak przestrzeń nazw istnieje, to funkcja zachowuje się tak, jakby nie podano tego parametru. ====== Łatwe sprawdzanie istnienia danej przestrzeni nazw ====== Sprawdzamy tutaj istnienie podanej przestrzeni nazw w parserach wikikodu {{Code|MediaWiki}}, wtedy dla nieistniejącej przestrzeni nazw otrrzymamy wynik pusty, a dla istniejącej już nie, wyjątkiem jest przestrzeń główna, dla której wartość otrzymana jest pusta, co nie trudno jest odróżnić od stanu błędu funkcji, chyba, że użyjemy pewnego parametru opisywanego poniżej: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Zwraca wartość: "Szablon": local nazwa_przestrzeni_nazw_1 = nazwy_modul.NpDane{ nazwa = "Szablon", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: "Moja przestrzeń": local nazwa_przestrzeni_nazw_2 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; ---- Zwraca wartość: nil: local nazwa_przestrzeni_nazw_3 = nazwy_modul.NpDane{ nazwa = "Moja przestrzeń", istnieje = "tak", ["wynik błędu nietekstowy"] = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> W kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} powyższe wywołanie przy nieznanych przestrzeniach przyjmuje wartość {{Code|nil}} (ostatni przykład), a wikikodzie w szablonach wartość pustą: "". A jeżeli chcemy sprawdzić, za pomocą funkcji parsera wikikodu: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}, używając odpowiednika szablonowego {{s|NpDane}}, wtedy musimy użyć parametru: {{Code|["wynik błędu nietekstowy"] {{=}} "tak"}}, używany z: {{Code|istnieje {{=}} "tak"}}, gdy dana przestrzeń nie istnieje, wtedy uzyskamy wartość pustą (bo wartość {{Code|nil}} jest tłumaczone na to), a żeby odróżnić ją od nazwy przestrzeni nazw głównej, to należy dodatkowo użyć: {{Code|["wyświetlana"] {{=}} "tak"}}, wtedy dla wartości pustej tej nazwy przestrzeni nazw, uzyskujemy w wyniku czego nie wartość pustą, czyli: {{Code|(główna)}} dla projektów polskich, lub po użyciu parametru {{Code|["po polsku"] {{=}} "tak"}} z wartością niepustą albo {{Code|(main)}} dla przestrzeni angielskich bądź innych, gdy nie ma obsługi w bazie przestrzeni nazw, tę nazwę można uzyskać też przy parametrze {{Code|kanoniczna {{=}} "tak"}} dla każdego obsługiwanego projektu {{Strong|wiki}}, więc przy takich realiach łatwo to odróżnić od komunikatu błędu tej funkcji. ===== Uzyskiwanie uchwytu danej przestrzeni nazw, analogicznie do funkcji {{Code|mw.site.namespaces}} (ale w sposób inny sformułowana), ale też z innym zestawem parametrów ===== Uchwyt niskopoziomowy do danej przestrzeni nazw nie można uzyskać przy pomocy kodu z: {{Code|mw.site.namespaces}}, ponieważ jest on dla przestrzeni na bieżącym projekcie, a tutaj mamy siostrzany. Funkcja uzyskująca uchwyt ignoruje wielkość liter w przestrzeni nazw oraz powtórzone odstępy zrealizowane za pomocą spacji lub dolnych myślników. To wysokopoziomowe uzyskanie uchwytu można utworzyć przy pomocy parametru: {{Code|uchwyt}}: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local uchwyt_1 = nazwy_modul.NpDane{ nazwa = "Szablon", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_2 = nazwy_modul.NpDane{ nazwa = "Template", uchwyt = "tak", ["klucz projektu"] = "pl:w", }; local uchwyt_3 = nazwy_modul.NpDane{ nazwa = 10, uchwyt = "tak", ["klucz projektu"] = "pl:w", }; </syntaxhighlight> Funkcja {{Code|nazwy_modul.NpDane}} jest bardziej ogólniejsza niż {{Code|mw.site.namespaces}} na projekcie bieżącym, ponieważ ona uwzględnia inne projekty niż polski {{NS|l=tak|w=tak}}, bo uwzględnia większą liczbę nazw przestrzeni nazw, czyli ona obejmuje wszystkie znane przestrzenie nazw, i dlatego należy stosować tę funkcję, a nie dedykowaną tabelę z połączoną z metatabelką za pomocą funkcji {{lpg|Lua}}. == Funkcje nazw serwisowych projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=d}} == === {{Code|m.NAZWASERWISU()}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy jest pod nazwą {{s|NAZWASERWISU}} (skrót: {{s|NS}}). Jego parametry są podobne do jego wersji bibliotecznej. Ten szablon wykorzystuje tę funkcję biblioteczną uruchamianą w ramce. ==== Funkcja biblioteczna ==== Szablon jest używany do uzyskania nazwy serwisu danej wiki, ewentualnie w postaci linku do strony głównej projektu danej wiki lub do artykułu o danej wiki na {{lpg|Wikipedia|Wikipedii}}, w jakieś podanej wersji językowej. {{OpisParametrów | 1 = Parametry podstawowe...| nagłówek1=tak | 2 = {{Parametr|wyspecjalizowana|tak}} | _2 = Tylko dla tej funkcji wywołanej w postaci ramki w wikikodzie w szablonach, gdy do niej wsadzamy bezpośrednio jako dzieci, a w przypadku z rodzica to ten parametr jest niepotrzebny lub powinien przyjmować wartość pustą, | 3 = Inne parametry...| nagłówek3=tak | 4 = Ta funkcja dalsze ma takie same parametry, co szablon w jego pełnej nazwie: {{s|NAZWASERWISU}}, lub skrótowej: {{s|NS}}.|nagłówek4=tak | 5 = Wszystkie powyższe zmienne są opcjonalne|nagłówek5=tak }} ===== Opis parametrów użytych razem z parametrem {{Code|link}} ===== Szablon przyjmuje parametr opcjonalny {{Code|link}} ({{s|NS|l{{=}}tak}}), dzięki któremu jest wyświetlany link, do strony głównej tego projektu, w postaci: {{Code|{{NS|l=tak}}}}, o nazwie linku, będącą jednocześnie nazwą serwisu projektu '''{{NS|l=tak}}'''. Gdy dodamy parametr {{Code|wikipedia{{=}}tak}} do wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}}, wtedy uzyskamy wynik: {{Code|{{NS|l=tak|w=tak}}}}, w innym przypadku, gdy linkujemy do angielskiej {{NS|w=tak|l=tak|pk=mj|k=tak}}, wtedy dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} mamy: {{Code|{{NS|l=tak|w=tak|kj=en}}}}, a w przypadku angielskiego {{NS|w=tak|l=tak|pk=d}} dla wikikodu {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} mamy wynik w postaci: {{Code|{{NS|l=tak|kj=en}}}}, a jeśli użyjemy parametru {{Code|kod projektu}}, wtedy wywołanie {{Code|{{s|NS|link{{=}}tak|kp{{=}}s}}}}, to mamy: {{Code|{{NS|l=tak|kp=s}}}}, a gdy dodamy dodatkowo {{Code|wikipedia{{=}}tak}}, zatem {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} jest o wyniku: {{Code|{{NS|l=tak|w=tak|kp=s}}}}. {{OpisParametrów | 1 = Wyniki z parametrem: {{Parametr|link|tak}}, zostały obtoczone znacznikiem: {{Tag|code}}, dla odróżnienia rezultatu od reszty tekstu.|nagłówek1=tak }} ===== Wywołania szablonu z tekstem z małymi literami po linku (parametr: {{Code|po}}) i z dowolnym tekstem w nazwie linku (parametr: {{Code|za}}) ===== {{OpisParametrów | 1 = Parametr: {{Parametr|link|tak}}, w szablonie: {{s|NAZWASERWISU}}, mówi, że ma być podany link do strony głównej projektu lub artykułu na {{NS|l=tak|k=w}}. Można w nie podać parametr: {{Parametr|po|<łańcuch tekstowy>}}, który jest za linkiem, podobnie: {{Parametr|za|<łańcuch tekstowy>}}, który jest w nazwie linku, ale względem jej originalnej nazwy za nim.|nagłówek1=tak }} ====== Proste przykłady użycia, z linkiem do projektu bieżącego, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do polskiego projektu {{NS|w=tak|l=tak|pk=mj}} do jego strony głównej. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|z=a}}}} ====== Proste przykłady użycia, z linkiem do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na polskiej {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z polską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} na podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. Jest to projekt: {{NS|l=tak|k=en:s}}, którego językiem jest: {{lpg|{{#invoke:lang|hasło|es}}}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|z=a}}}} ====== Przykłady użycia, z linkiem do obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}, z niepolską podanego nazwą projektu, przy użyciu parametru {{Code|link}} ====== Gdy chcemy wyświetlić link do artykułu o {{NS|w=tak|l=tak|k=b|pk=mj}} do podanej obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}} podany za pomocą parametru {{Code|["klucz projektu"] {{=}} "en:s"}}. A nazwa linku ma być podana w języku tego projektu. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", po = "a", }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["klucz projektu"] = "en:s", ["w języku wiki"] = "tak", za = "a", }; </syntaxhighlight> ; Analogiczne wywołanie szablonu{{Dk}} * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}} → {{Tt|{{NS|l=tak|w=tak|k=en:s|jw=tak|z=a}}}}. ; Kod wywołania tych szablonów: ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|p{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|p=a}}}} ;; Dla wywołania {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|k{{=}}en:s|jw{{=}}tak|z{{=}}a}}}}{{Dk}} {{PreNowiki|{{NS|l=tak|w=tak|k=en:s|jw=tak|za=a}}}} ===== Wywołania szablonu dotyczące, w {{NS|w=tak|l=tak|k=w|pk=mj}} iub nie, kodzie dla projektu {{NS|w=tak|l=tak|pk=m}} dla różnych wersji językowych ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę projektu w postaci linku do artykułu strony głównej na {{NS|w=tak|l=tak|pk=mj}} lub artykułu na polskiej lub obcojęzycznej {{NS|w=tak|l=tak|k=w|pk=mj}}. Do jakiej {{NS|w=tak|l=tak|k=w|pk=mj}} ma być link, to wskazuje kod języka, np.: {{Code|["kod języka"] {{=}} "en"}}. Gdy nie podamy tego kodu, to linkujemy tylko do polskiego {{NS|w=tak|l=tak|pk=mj}} lub do polskiej {{NS|w=tak|l=tak|k=w|pk=mj}} (jeżeli podamy parametr {{Code|wikipedia {{=}} "tak"}}). A gdy podany jest ten kod, to możemy linkować nie tylko do polskich projektów siostrzanych polskiego {{NS|w=tak|l=tak|pk=mj}} (ale tylko różnych jego wersji językowych), ale też można linkować do obcojęzycznych projektów, którym jest Wikipedia do artykułu o tym projekcie. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISSU{}; }; local link_2 = nazwy_modul.NAZWASERWISU{ link = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", }; local link_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", }; local link_5 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", }; local link_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", }; local link_7 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS}}}} → {{Tt|{{NS}}}}, * {{Code|{{s|NS|l{{=}}tak}}}} → {{Tt|{{NS|l=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|kj=en}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en}}}}. ===== Wywołanie szablonu dotyczące innego projektu niż ten ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Ale też możemy linkować do stron głównych innych projektów niż {{NS|w=tak|l=tak|pk=m}}. Robimy to za pomocą parametru: {{Code|["kod projektu"] {{=}} "s"}}, nie licąc parametru języka, ale też możemy linkować do artykułu o danym projekcie na {{NS|w=tak|l=tak|k=w|pk=mj}}. A jeżeli podamy kod języka {{Code|["kod języka"] {{=}} "en"}}, wtedy linkujemy do angielskich projektów, w tym również do {{NS|w=tak|l=tak|k=w|pk=mj}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); ---- Tutaj linkujemy do Wikiźródeł do jej strony głównej local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", }; --- Co powyżej, tylko do artykułu na Wikipedii o Wikiźródłach local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s", }; -- Tutaj linkujemy do Wikibooksa do jej strony głównej w jakieś jej wersji językowej local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; -- Jak powyżej, tylko do artykułu Wikipedii w jakieś wersji językowej o Wikiźródłach local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s}}}}. ===== Wywołania szablonu z nazwą linku danej wiki ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Gdy chcemy podać nazwę linku przy pomocy parametru {{Code|["w języku wiki"] {{=}} "tak"}}, w języku danej wiki, którego podajemy przy parametrze {{Code|["kod języka"] {{=}} "en"}}, dla projektu podanego w zmiennej {{Code|["kod projektu"] {{=}} "s"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local linki_1 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_2 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["w języku wiki"] = "tak", }; local linki_3 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_4 = nazwy_modul.NAZWASERWISU{ link = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_5 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "pl", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; local linki_6 = nazwy_modul.NAZWASERWISU{ link = "tak", wikipedia = "tak", ["kod języka"] = "en", ["kod projektu"] = "s", ["w języku wiki"] = "tak", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|l{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|kj=en|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}pl|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=pl|kp=s|jw=tak}}}}, * {{Code|{{s|NS|l{{=}}tak|w{{=}}tak|kj{{=}}en|kp{{=}}s|jw{{=}}tak}}}} → {{Tt|{{NS|l=tak|w=tak|kj=en|kp=s|jw=tak}}}}. ===== Wywołanie szablonu z podaną nazwą linku ===== ====== Przykłady użycia funkcji {{Code|nazwy_modul.NAZWASERWISU()}} ====== Jeżeli chcemy podać ściśle określony ciąg, który jest nazwą linku, do linkowania do strony głównej lub artykułu na {{NS|w=tak|l=tak|k=w|pk=mj}} o danym projekcie, np. inną niż nazwa projektu. Tutaj nazwą linku jest {{Code|[1] {{=}} "Biblioteka książek"}}. <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); local link_1 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", }; local link_2 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", }; local link_3 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; local link_4 = nazwy_modul.NAZWASERWISU{ [1] = "Biblioteka książek", link = "tak", wikipedia = "tak", ["kod projektu"] = "s",["kod języka"] = "en", }; </syntaxhighlight> ====== Analogiczne wywołanie szablonu ====== * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak}}}}, * {{Code|{{s|NS|Biblioteka książek|l{{=}}tak|w{{=}}tak}}}} → {{Tt|{{NS|Biblioteka książek|l=tak|w=tak}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|kp=s|kj=en}}}}, * {{Code|{{s|NS|Biblioteka wikiźródeł|l{{=}}tak|w{{=}}tak|kp{{=}}s|kj{{=}}en}}}} → {{Tt|{{NS|Biblioteka wikiźródeł|l=tak|w=tak|kp=s|kj=en}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> je4f913wwz9xiu9rhw2376tl0j44gsm 4 63967 555808 555632 2026-09-12T11:41:20Z Persino 2851 555808 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}} Są tutaj przedstawione funkcje liczb elementów w tabeli lub szablonów, w wersji mnogiej lub normalnej. == {{Code|p["LiczbaElementówNumerowanychTablicy"]}} == Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw, zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Ona liczy liczbę parametrów numerowanych niepustych, tzn. elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, na którym operujemy. | 2 = {{Code|wliczac}} | _2 = Czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}. | 3 = {{Code|mnoga}} | _3 = Czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. }} === Przykład kodu na stronie modułów z przykładami na stronie ich opisów === Popatrz na wyniki kodu, w {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w specjalnej ramce w: {{m|Wikibooks/Przykład/Parametry/LiczbaElementówNumerowanychTablicy/}}. == {{Code|p["LiczbaElementówNumerowanychSzablonu"]}} == Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: {{OpisParametrów | 1 = {{Code|niepuste}} | _1 = 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. | 2 = {{Code|mnoga}} | _2 = Czy liczba takich wyszukań jest mnoga, jeżeli niepusta. }} Odpowiednikiem zmiennej {{Code|tabela}}: {{OpisParametrów | 1 = {{Code|frame:getParent().args}} | _1 = Parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. }} Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. == {{Code|p["LiczbaElementówNienazwanychTablicy"]}} == Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, na którym operujemy. | 2 = {{Code|wliczac}} | _2 = Czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, | 3 = {{Code|mnoga}} | _3 = Czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. }} Funkcja z użytym parametrem {{Code|mnoga}} z wartością {{Code|true}} jest taka, że zawsze zwracana jest wartość {{Code|2}} przez nią. === Przykład kodu na stronie modułów z przykładami na stronie ich opisów === Popatrz na wyniki kodu, w {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w specjalnej ramce w: {{m|Wikibooks/Przykład/Parametry/LiczbaElementówNienazwanychTablicy/}}. == {{Code|p["LiczbaParametrówNienazwanychSzablonu"]}} == Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: {{OpisParametrów | 1 = {{Code|niepuste}} | _1 = 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. | 2 = {{Code|mnoga}} | _2 = Czy liczba takich wyszukań jest mnoga, jeżeli niepusty. }} Odpowiednikiem parametru {{Code|tabela}} jest: {{OpisParametrów | 1 = {{Code|frame:getParent().args}} | _1 = Parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. }} Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu na to ustawienie w dziecku, jako liczbę {{Code|2}}, a nie {{Code|4}}. == {{Code|p["LiczbaElementówTablicy"]}} == Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela do rozważań na problemy tej funkcji. | 2 = {{Code|wliczac}} | _2 = Czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. }} === Przykład kodu na stronie modułów z przykładami na stronie ich opisów === Popatrz na wyniki kodu, w {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w specjalnej ramce w: {{m|Wikibooks/Przykład/Parametry/LiczbaElementówTablicy/}}. == {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]}} == Funkcja liczy liczbę nienazwanych elementów 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}}, wtedy ta funkcja zwraca wynik {{Code|2}}, a jeżeli nie jest taka, to wtedy zwracany wynik jest {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu znakowym. Należy wskazać w funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami znakowymi, a jeżeli nie są takie, to one muszą być w postaci czystych liczb. Definicja form numerkowych jest taka, że one po przekształceniu na liczbę funkcją {{LzLua|tonumber}} stają się normalnymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, na którym operujemy. | 2 = {{Code|przedrostek}} | _2 = Niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą. | 3 = {{Code|wliczac}} | _3 = Czy szukamy niepuste elementy numerowane tabeli. | 4 = {{Code|czy_formy_numerkowe}} | _4 = Czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. }} Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. === Przykład kodu na stronie modułów z przykładami na stronie ich opisów === Popatrz na wyniki kodu, w {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w specjalnej ramce w: {{m|Wikibooks/Przykład/Parametry/LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy/}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> r6teyhm72uqdu038z5lb28k5y7zsr37 4 63972 555783 555639 2026-09-12T01:16:49Z Persino 2851 /* p["Odstępy"] */ 555783 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}} Są tutaj przedstawione funkcje manipulowania formatami łańcuchów znakowych. == {{Śródtytuł|p["Odstępy"]}}{{Code|p["Odstępy"]}} == === Odpowiednik szablonowy === Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. === Funkcja biblioteczna === Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|1}} lub {{Code|nazwa}} | _1 = Określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha. | 2 = {{Code|2}} lub {{Code|wewnątrz}} | _2 = Czy ma również robić podobne operacje, co powyżej, tylko że wewnątrz ciągu, z różnicą, że zaamieniając na jeden znak. | 3 = {{Code|3}} lub {{Code|dolny-myślnik}} | _3 = Czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki. | 4 = {{Code|4}} lub {{Code|spacje}} | _4 = Czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. }} Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7tlr3b5o4rq9unazjg695g7dx7r32f5 4 63975 555672 555643 2026-09-11T13:04:13Z Persino 2851 555672 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}} Są tutaj przedstawione funkcje łączenia wielu tabel. == {{Code|p["ŁączDwieTabele"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}} i {{Code|tabela2}} | _1 = tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość10","wartość11","wartość12","wartość5","wartość6","wartość17","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość10","wartość11","wartość12","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączNumerowaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączNienazwaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączTabele"]}} == Funkcja łączy tabele ogólnie nazwane, określone w tablicy: {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tabela elementów będących tabelami. | 2 = {{Code|args2}} | _2 = Tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. }} Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: {{OpisParametrów | 1 = {{Code|args2.CzyPairsTablic}} | _1 = Jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane. | 2 = {{Code|args2["CzyPairsElementówTablic"]}} | _2 = Jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane. | 3 = {{Code|args2.CzyNazwaneElementyTabel}} | _3 = Jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę. | 4 = {{Code|args2.CzyTylkoNazwaneElementyTabel}} | _4 = Jeśli niepuste, łączy tylko nazwane elementy tabel. | 5 = {{Code|args2.NazwijElementyNumerowane}} | _5 = 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. }} Funkcje łączenia tabel w przweróźny sposób, zdefiniowane w: {{OpisParametrów | 1 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]|p=Parametry}}}} | _1 = Łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. | 2 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _2 = Łaczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. | 3 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _3 = Łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. | 4 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}} | _4 = Łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. | 5 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _5 = Łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. | 6 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _6 = Łączy tylko elementy nazwane tabel, tabel ponumerowanych. }} Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} {{OpisParametrów | 1 = {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}} | _1 = Łączy tabele ponumerowane,. | 2 = {{Code|{{sr|#p["ŁączNienazwaneTabele"]|p=Parametry}}}} | _2 = Łą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. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> s2n38d60xzs4ea9w5tnfqzje9vwspdi 555676 555672 2026-09-11T13:14:24Z Persino 2851 /* {{Code|p["ŁączTabele"]}} */ 555676 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}} Są tutaj przedstawione funkcje łączenia wielu tabel. == {{Code|p["ŁączDwieTabele"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}} i {{Code|tabela2}} | _1 = tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość10","wartość11","wartość12","wartość5","wartość6","wartość17","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość10","wartość11","wartość12","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączNumerowaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączNienazwaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączTabele"]}} == Funkcja łączy tabele ogólnie nazwane, określone w tablicy: {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tabela elementów będących tabelami. | 2 = {{Code|args2}} | _2 = Tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. }} Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: {{OpisParametrów | 1 = {{Code|args2.CzyPairsTablic}} | _1 = Jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane. | 2 = {{Code|args2["CzyPairsElementówTablic"]}} | _2 = Jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane. | 3 = {{Code|args2.CzyNazwaneElementyTabel}} | _3 = Jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę. | 4 = {{Code|args2.CzyTylkoNazwaneElementyTabel}} | _4 = Jeśli niepuste, łączy tylko nazwane elementy tabel. | 5 = {{Code|args2.NazwijElementyNumerowane}} | _5 = 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. }} Funkcje łączenia tabel w przweróźny sposób, zdefiniowane w: {{OpisParametrów|klasa=Opis-Szerokość | 1 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]|p=Parametry}}}} | _1 = Łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. | 2 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _2 = Łaczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. | 3 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _3 = Łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. | 4 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}} | _4 = Łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. | 5 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _5 = Łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. | 6 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _6 = Łączy tylko elementy nazwane tabel, tabel ponumerowanych. }} Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} {{OpisParametrów | 1 = {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}} | _1 = Łączy tabele ponumerowane,. | 2 = {{Code|{{sr|#p["ŁączNienazwaneTabele"]|p=Parametry}}}} | _2 = Łą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. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cas3fuy4fg580mw9bu6fhvr2fjkitn7 555678 555676 2026-09-11T13:15:17Z Persino 2851 /* {{Code|p["ŁączTabele"]}} */ 555678 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}} Są tutaj przedstawione funkcje łączenia wielu tabel. == {{Code|p["ŁączDwieTabele"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}} i {{Code|tabela2}} | _1 = tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość10","wartość11","wartość12","wartość5","wartość6","wartość17","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość10","wartość11","wartość12","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączNumerowaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączNienazwaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączTabele"]}} == Funkcja łączy tabele ogólnie nazwane, określone w tablicy: {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tabela elementów będących tabelami. | 2 = {{Code|args2}} | _2 = Tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. }} Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: {{OpisParametrów | 1 = {{Code|args2.CzyPairsTablic}} | _1 = Jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane. | 2 = {{Code|args2["CzyPairsElementówTablic"]}} | _2 = Jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane. | 3 = {{Code|args2.CzyNazwaneElementyTabel}} | _3 = Jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę. | 4 = {{Code|args2.CzyTylkoNazwaneElementyTabel}} | _4 = Jeśli niepuste, łączy tylko nazwane elementy tabel. | 5 = {{Code|args2.NazwijElementyNumerowane}} | _5 = 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. }} Funkcje łączenia tabel w przweróźny sposób, zdefiniowane w: {{OpisParametrów|klasa=Opis-Szerokość-1 | 1 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]|p=Parametry}}}} | _1 = Łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. | 2 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _2 = Łaczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. | 3 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _3 = Łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. | 4 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}} | _4 = Łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. | 5 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _5 = Łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. | 6 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _6 = Łączy tylko elementy nazwane tabel, tabel ponumerowanych. }} Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} {{OpisParametrów | 1 = {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}} | _1 = Łączy tabele ponumerowane,. | 2 = {{Code|{{sr|#p["ŁączNienazwaneTabele"]|p=Parametry}}}} | _2 = Łą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. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> e8q67nhez4f4zcj86qapnddkzx47u87 555683 555678 2026-09-11T13:29:15Z Persino 2851 /* {{Code|p["ŁączTabele"]}} */ 555683 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}} Są tutaj przedstawione funkcje łączenia wielu tabel. == {{Code|p["ŁączDwieTabele"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}} i {{Code|tabela2}} | _1 = tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość10","wartość11","wartość12","wartość5","wartość6","wartość17","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość10","wartość11","wartość12","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączNumerowaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączNienazwaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączTabele"]}} == Funkcja łączy tabele ogólnie nazwane, określone w tablicy: {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tabela elementów będących tabelami. | 2 = {{Code|args2}} | _2 = Tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. }} Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: {{OpisParametrów | 1 = {{Code|args2.CzyPairsTablic}} | _1 = Jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane. | 2 = {{Code|args2["CzyPairsElementówTablic"]}} | _2 = Jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane. | 3 = {{Code|args2.CzyNazwaneElementyTabel}} | _3 = Jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę. | 4 = {{Code|args2.CzyTylkoNazwaneElementyTabel}} | _4 = Jeśli niepuste, łączy tylko nazwane elementy tabel. | 5 = {{Code|args2.NazwijElementyNumerowane}} | _5 = 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. }} Funkcje łączenia tabel w przweróźny sposób, zdefiniowane w: {{OpisParametrów|klasa=Opis-Szerokość-1 | 1 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]|p=Parametry}}}} | _1 = Łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. | 2 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _2 = Łaczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. | 3 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _3 = Łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. | 4 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}} | _4 = Łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. | 5 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _5 = Łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. | 6 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _6 = Łączy tylko elementy nazwane tabel, tabel ponumerowanych. }} Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} {{OpisParametrów | 1 = {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}} | _1 = Łączy tabele ponumerowane. | 2 = {{Code|{{sr|#p["ŁączNienazwaneTabele"]|p=Parametry}}}} | _2 = Łą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. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ce08zajd7slg39zccklp4agkaoojj96 555684 555683 2026-09-11T13:31:47Z Persino 2851 /* {{Code|p["ŁączDwieTabele"]}} */ 555684 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}} Są tutaj przedstawione funkcje łączenia wielu tabel. == {{Code|p["ŁączDwieTabele"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}} i {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|tabela1}}, {{Code|tabela2}} | _1 = Tabele do połączenia w jedną tablicę. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]}} == Funkcja łączy dwie tabele przy pomocy: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość10","wartość11","wartość12","wartość5","wartość6","wartość17","wartość8","wartość9",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość10","wartość11","wartość12","wartość8","wartość5","wartość7","wartość9","wartość6",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość4","wartość1","wartość2","wartość3","wartość8","wartość5","wartość7","wartość9","wartość6","wartość10","wartość11","wartość12",}; </syntaxhighlight> == {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> == {{Code|p["ŁączNumerowaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączNienazwaneTabele"]}} == Funkcja wykorzystuje: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tablica elementów będących elementami. }} Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[9]="wartość24",}; </syntaxhighlight> == {{Code|p["ŁączTabele"]}} == Funkcja łączy tabele ogólnie nazwane, określone w tablicy: {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args}} | _1 = Tabela elementów będących tabelami. | 2 = {{Code|args2}} | _2 = Tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. }} Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: {{OpisParametrów | 1 = {{Code|args2.CzyPairsTablic}} | _1 = Jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane. | 2 = {{Code|args2["CzyPairsElementówTablic"]}} | _2 = Jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane. | 3 = {{Code|args2.CzyNazwaneElementyTabel}} | _3 = Jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę. | 4 = {{Code|args2.CzyTylkoNazwaneElementyTabel}} | _4 = Jeśli niepuste, łączy tylko nazwane elementy tabel. | 5 = {{Code|args2.NazwijElementyNumerowane}} | _5 = 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. }} Funkcje łączenia tabel w przweróźny sposób, zdefiniowane w: {{OpisParametrów|klasa=Opis-Szerokość-1 | 1 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]|p=Parametry}}}} | _1 = Łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. | 2 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _2 = Łaczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. | 3 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]|p=Parametry}}}} | _3 = Łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. | 4 = {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]|p=Parametry}}}} | _4 = Łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. | 5 = {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _5 = Łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. | 6 = {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]|p=Parametry}}}} | _6 = Łączy tylko elementy nazwane tabel, tabel ponumerowanych. }} Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} {{OpisParametrów | 1 = {{Code|{{sr|#p["ŁączNumerowaneTabele"]|p=Parametry}}}} | _1 = Łączy tabele ponumerowane. | 2 = {{Code|{{sr|#p["ŁączNienazwaneTabele"]|p=Parametry}}}} | _2 = Łą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. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> qc80ieffaxablnvj2q5ucj6ivmdi28n 4 63977 555668 555645 2026-09-11T12:40:56Z Persino 2851 555668 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}} Są tutaj przedstawwione funkcje tworzenia tabeli. == {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]}} == Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args[1]}} | _1 = Tabela elementów. | 2 = {{Code|args[2]}}, {{Code|args[3]}},... | _2 = Tabele od drugiej wzwyż, którym dzięki im kluczom są usuwane elementy z tej pierwszej. }} Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabela_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> tutfagu1ucr6bf6cee5frxmhxk2vevm 555669 555668 2026-09-11T12:41:13Z Persino 2851 555669 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}} Są tutaj przedstawwione funkcje tworzenia tabeli. == {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]}} == Funkcja jest analogiem do {{Code|{{sr|#p["UsuńElementyTabeli"]|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args[1]}} | _1 = Tabela elementów. | 2 = {{Code|args[2]}}, {{Code|args[3]}},... | _2 = Tabele od drugiej wzwyż, którym dzięki im kluczom są usuwane elementy z tej pierwszej. }} Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabela_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ahgblihsfmt1lhm1lpp8vk2mi2gu7u1 555670 555669 2026-09-11T12:41:30Z Persino 2851 555670 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}} Są tutaj przedstawwione funkcje tworzenia tabeli. == {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]}} == Funkcja jest analogiem do: {{Code|{{sr|#p["UsuńElementyTabeli"]|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args[1]}} | _1 = Tabela elementów. | 2 = {{Code|args[2]}}, {{Code|args[3]}},... | _2 = Tabele od drugiej wzwyż, którym dzięki im kluczom są usuwane elementy z tej pierwszej. }} Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabela_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> olju14zqrktcuitrdwgx4sw7gdci9if 555671 555670 2026-09-11T12:44:36Z Persino 2851 555671 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}} Są tutaj przedstawwione funkcje tworzenia tabeli. == {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]}} == Funkcja jest analogiem do: {{Code|{{sr|#p["UsuńElementyTabeli"]|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce: {{Code|args[1]}}, przy pomocy, której niej, tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były to jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów| | 1 = {{Code|args[1]}} | _1 = Tabela elementów. | 2 = {{Code|args[2]}}, {{Code|args[3]}},... | _2 = Tabele od drugiej wzwyż, którym dzięki im kluczom są usuwane elementy z tej pierwszej. }} Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabela_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> pyct72tgt8pu7eic6df9kvvo3esd540 4 63979 555759 555647 2026-09-11T23:08:47Z Persino 2851 /* */ 555759 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. == Wzajemna zależność == W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. == Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej == === Parametr typu {{Code|string}} === Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. === Typu {{Code|number}} === Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. === Typu {{Code|boolean}} === Czy wartością logiczną jest jako {{Code|true}}. === Typu {{Code|table}} === Dla tabel, czy jest niepustą tabelą. === Typu {{Code|function}} === Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, == Zwracane wartości == Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> hevz61ed1yh0n9i96oyi911j91yi4tb 555760 555759 2026-09-11T23:10:49Z Persino 2851 /* Wzajemna zależność */ 555760 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. == Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej == === Parametr typu {{Code|string}} === Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. === Typu {{Code|number}} === Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. === Typu {{Code|boolean}} === Czy wartością logiczną jest jako {{Code|true}}. === Typu {{Code|table}} === Dla tabel, czy jest niepustą tabelą. === Typu {{Code|function}} === Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, == Zwracane wartości == Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 102n7wulqh3j0fsclrmo47yvmkg7kbu 555761 555760 2026-09-11T23:11:53Z Persino 2851 555761 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, == Zwracane wartości == Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cmzi74ylwi27b7zpdg4m3tp75kwfi0d 555762 555761 2026-09-11T23:12:24Z Persino 2851 555762 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> qxp7qqinang55rhs6apm82v3eimaed6 555763 555762 2026-09-11T23:13:59Z Persino 2851 555763 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ld0em8jjzhqoa5zhzhl6uzjz65k2dnn 555764 555763 2026-09-11T23:47:21Z Persino 2851 /* CzyTakSilnik */ 555764 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> tbk6uy81suuolgu1kh5xz9urd4dg7xl 555765 555764 2026-09-11T23:59:13Z Persino 2851 /* p["CzyTakCiąg"] */ 555765 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9yt2d1towg2l8exoowrklzt8efeegsk 555766 555765 2026-09-12T00:08:29Z Persino 2851 /* p.CzyTak */ 555766 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9bzzxgf3o3u2btpgvr1gnvah1uqrcmv 555767 555766 2026-09-12T00:26:07Z Persino 2851 /* p["CzyTakCiąg"] */ 555767 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7ygblxuvtrl8izl9zr1q7j0ll0nhrbm 555768 555767 2026-09-12T00:28:22Z Persino 2851 /* CzyTakSilnik */ 555768 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> t7m9v0znlzo8mrgmistdkyubzd2lyh6 555769 555768 2026-09-12T00:30:36Z Persino 2851 /* p["CzyTakCiąg"] */ 555769 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. == {{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> kts0bzz073s0ifmbhjd0z8fu7b80gqv 555770 555769 2026-09-12T00:31:58Z Persino 2851 555770 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 5lrgnrrepyrjb1u5y4ikezimqqtoehn 555771 555770 2026-09-12T00:35:48Z Persino 2851 /* Funkcje prawdy i fałszu - ogólne przedstawienie */ 555771 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> abn03xopumqre5q9pch0ehoombw47ht 555772 555771 2026-09-12T00:38:40Z Persino 2851 /* Atrapa funkcji parametrów ramki rodzica (szablonu) */ 555772 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nyf1sqthea3qtqfj89r9x2cu242uxc0 555773 555772 2026-09-12T00:45:21Z Persino 2851 /* p["CzyTakCiąg"] */ 555773 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9jgr3k0hrwfggyopf5c724wyucktana 555774 555773 2026-09-12T00:46:36Z Persino 2851 /* p["CzyTakCiąg"] */ 555774 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{Code|p["CzyTakCiąg"]}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 6jql4sqw2cjc0i4qhnd7nukfqdil9uz 555775 555774 2026-09-12T00:49:07Z Persino 2851 /* p["CzyTakCiąg"] */ 555775 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== 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}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7bb7m9g7466b2atgbw6wapotsazvfll 555776 555775 2026-09-12T00:51:45Z Persino 2851 /* Ciąg składający się z samych odstępów - wartość zwracana */ 555776 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} == W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"]|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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}}}} ==== Ciąg z samych znaków odstępów ==== 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. ==== Ciąg pusty - jego rewidowanie ==== <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}}}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bmzai278aqv9uy08kpojm04ixq1v2io 555777 555776 2026-09-12T00:57:40Z Persino 2851 /* p.CzyTak */ 555777 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2s91w9g3coisj1yjgqbcp40efgzrnqm 555778 555777 2026-09-12T01:04:38Z Persino 2851 /* p.CzyTak */ 555778 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną tablicę {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> g476iv3jqvwvle6f5pf5xr1xnf8v5iz 555779 555778 2026-09-12T01:05:46Z Persino 2851 /* p.CzyTak */ 555779 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> mbw3g5ebdgmgbv00w8y6tq0koigh2ip 555780 555779 2026-09-12T01:08:50Z Persino 2851 /* p["CzyTakCiąg"] */ 555780 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = zmienna | _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = parametry | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 727mfubliih6emxly20nw78azjl32xf 555781 555780 2026-09-12T01:12:17Z Persino 2851 /* p["CzyTakCiąg"] */ 555781 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}}| _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|1}} lub {{Code|zmienna}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|2}} lub {{Code|parametry}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> m9nvcqfibtaqcgqs3xycv70mf6gcx42 555782 555781 2026-09-12T01:14:10Z Persino 2851 /* p.CzyTak */ 555782 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === 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). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== Jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg). Po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}}| _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 0e2m5befe06s3sta3686o7wmg8kr1xv 555784 555782 2026-09-12T01:24:03Z Persino 2851 /* CzyTakSilnik */ 555784 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== 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ą: {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}}| _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> h9bk91if7ac09g3c2okeyctartbzbtd 555785 555784 2026-09-12T01:28:47Z Persino 2851 /* p["CzyTakCiąg"] */ 555785 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== 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ą: {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} i {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}}| _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1xz751rf1m3q9k4pt0xu8qh7spz14zu 555786 555785 2026-09-12T01:31:37Z Persino 2851 /* p.CzyTak */ 555786 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== 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ą: {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} i {{LinkŚródtytuł|p.CzyTak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}}| _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, tak jak to robi {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> p5twaq563bdtjwinwuxeizvbpsb6r8h 555791 555786 2026-09-12T07:19:10Z Persino 2851 /* {{Śródtytuł|p["CzyTakCiąg"]}}{{Code|p["CzyTakCiąg"]}} */ 555791 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== 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ą: {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} i {{LinkŚródtytuł|p.CzyTak}}. Funkcja sprawdza, czy strimowany ciąg, czy jest nierówny ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}}| _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, tak jak to robi {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 61a7xss9ha182n7e4tlh927604pnwig 555792 555791 2026-09-12T07:19:51Z Persino 2851 /* {{Śródtytuł|p.CzyTak}}{{Code|p.CzyTak}} */ 555792 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}} == Funkcje prawdy i fałszu - ogólne przedstawienie == W funkcjach: {{LinkŚródtytuł|p["CzyTakCiąg"]}} i {{LinkŚródtytuł|p.CzyTak}}, 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. === Wzajemna zależność === W tej pierwszej funkcji jest wykorzystywana ta druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jest funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. === Uzyskiwane wyniki w zależności od sprawdzanego parametru - różne typy wartości pierwszej zmiennej === ==== Parametr typu {{Code|string}} ==== Te funkcje rozważane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy nie jest ciągiem pustym. ==== Typu {{Code|number}} ==== Jeżeli jest to liczba, to czy jest nie równa {{Code|0}}. ==== Typu {{Code|boolean}} ==== Czy wartością logiczną jest jako {{Code|true}}. ==== Typu {{Code|table}} ==== Dla tabel, czy jest niepustą tabelą. ==== Typu {{Code|function}} ==== Ale za to w przypadku funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, === Zwracane wartości === Jeżeli funkcja zwróci wartość odpowiadająca prawdziwej, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, wartość {{Code|nil}}. == {{Śródtytuł|CzyTakSilnik}}{{Code|CzyTakSilnik}} == Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|args}} | _1 = Tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji. | 2 = {{Code|funkcja}} | _2 = Funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. }} === Możliwe wartości drugiego parametru - funkcji === Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). === Sprawdzanie prawdziwości funkcji z jej zrzucanej, wartości === Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, a jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. === Brak składowej drugiej tablicy, co świadczy, że nie sprawdzamy funkcji, tylko co innego === ==== Rewidowana jest liczba lub ciąg znaków liczba ==== 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. ==== Typ - ciag znaków ==== 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ą: {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. === Walidacja przygotowanych parametrów podaną funkcją === Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji. ==== Przypadek uruchamiania funkcji w kodzie ==== W postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. ==== Procedura zwracając wartość z ramki wiki kodu ==== 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. === Atrapa funkcji parametrów ramki rodzica (szablonu) === Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. == {{Śródtytuł|p["CzyTakCiąg"]}}{{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 {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}} i {{LinkŚródtytuł|p.CzyTak}}. Funkcja sprawdza, czy strimowany ciąg, czy jest nierówny ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}}| _1 = Funkcja - typ: {{Code|function}}, lub inna wartość sprawdzana, np. {{Code|string}}, czy odpowiada wartości prawdziwej. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji sprawdzanej, gdy zmienna: {{Code|zmienna}}, jest funkcją. }} Funkcja, gdy jest uruchamiania w ramce, to wtedy elementem sprawdzany jest tablica ramki tablicy transportu modułu, a ponieważ ma ona w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, to wtedy jest uruchamiania funkcja: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTakCiąg}}. === Funkcja uruchamiania w ramce wiki kodu === ==== Normalne znaki z odstępami ==== Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> ==== Ciąg składający się z samych odstępów - wartość zwracana ==== To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{LinkŚródtytuł|p.CzyTak}}, 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 {{LinkŚródtytuł|p.CzyTak}} zwróci wartość {{Code|tak}}. === Funkcja uruchamiania w postaci funkcji bibliotecznej === ==== Ciąg z treściwymi znakami z odstępami ==== Podobnie 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}}. ==== Brak takich znaków, tylko same odstępy ==== 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}}. == {{Śródtytuł|p.CzyTak}}{{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 {{LinkŚródtytuł|p["Odstępy"]|Parametry/Tom VI}}, tak jak to robi {{LinkŚródtytuł|p["CzyTakCiąg"]}}. Funkcja sprawdza, czy niestrimowany ciąg, czy jest nierówny ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|zmienna}} lub {{Code|1}} | _1 = Sprawdzana zmienna, może być to funkcją. | 2 = {{Code|parametry}} lub {{Code|2}} | _2 = Parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. }} W przypadku uruchamiania funkcji w ramce, wtedy parametrem pierwszym tej funkcji jest tablica ramka wikikodu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, więc ma w sobie zdefiniowaną funkcję: {{LzLua|frame:getParent}}, stąd wtedy jest stosowana funkcja lokalna: {{LinkŚródtytuł|CzyTakSilnik}}, z drugim parametrem: {{Code|CzyTak}}. === Funkcja działająca w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === ==== Ciąg niepusty z treściwymi znakami z odstępami ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} ==== Ciąg z samych znaków odstępów ==== 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 {{LinkŚródtytuł|p["CzyTakCiąg"]}} zwróci wartość równoważną ciągowi pustemu. ==== Ciąg pusty - jego rewidowanie ==== <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 {{LinkŚródtytuł|p["CzyTakCiąg"]}}. === W postaci funkcji bibliotecznej - nie ramki === ==== Treściwe znaki z odstępami ==== Podobnie 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}}. ==== Same odstępy ==== 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. ==== Ciąg pusty ==== 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}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> fckpv8606o9dk5cubjs24iy9plhado7 4 63980 555730 555648 2026-09-11T18:32:06Z Persino 2851 /* {{Code|p.PobierzParametr}} */ 555730 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, 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 zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> jp2w8qmvke9ffmyc50fdy63by2hvasv 555731 555730 2026-09-11T18:37:35Z Persino 2851 /* {{Code|p.PobierzParametryRamki}} */ 555731 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> t3mp2s76d82zkht4dxv1rp5s6dgxs9n 555732 555731 2026-09-11T18:38:49Z Persino 2851 /* {{Code|p.PobierzParametryRamki}} */ 555732 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 99cjaniaivqbc70iu4m1xzi2yyx7klu 555733 555732 2026-09-11T18:55:57Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} */ 555733 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 5p0jqxbc2jyje5a9vxdxpy1dcb6yh90 555734 555733 2026-09-11T19:03:12Z Persino 2851 /* {{Code|p.PobierzParametr}} */ 555734 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> q57svbjfkj1fkc3wrukwc9uzs8v8sjd 555735 555734 2026-09-11T19:07:05Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent}} */ 555735 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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ć uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 47r3vuhaamho3p4kkph0jl34sbe7thp 555736 555735 2026-09-11T19:08:25Z Persino 2851 /* Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy */ 555736 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1eg1cr6zkzi65ososj7xb0s62nj3k7q 555737 555736 2026-09-11T19:28:13Z Persino 2851 /* {{Code|p.PobierzParametryRamki}} */ 555737 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykłąd wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> tq6d12w5h27qqe5t1e4sexs0dprufqt 555738 555737 2026-09-11T19:37:22Z Persino 2851 /* {{Code|p.PobierzArgsParametry}} */ 555738 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania fubkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> ==== Usunięcie niedogodności ==== Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykłąd wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> jqittdsewto9c3r656314w1gjvitmr7 555739 555738 2026-09-11T19:37:58Z Persino 2851 /* Usunięcie niedogodności */ 555739 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania fubkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykłąd wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cu3mhulbp6jjf05kzre3ai7q6j8lh6b 555740 555739 2026-09-11T19:38:36Z Persino 2851 /* Funkcje, funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} */ 555740 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania fubkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykłąd wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 87d955h16yl8wqntzzhztj1cqfb08vz 555741 555740 2026-09-11T19:40:14Z Persino 2851 /* Wywołania funkcji */ 555741 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania fubkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykłąd wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 4dw2b4ucmtngwxkw9t3y3j99rouln1c 555742 555741 2026-09-11T19:41:02Z Persino 2851 /* Przykład wywołania fubkcji z funkcją parametrów */ 555742 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykłąd wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 8uhhrrxe20zwcydrm4yka7sn6c183ct 555743 555742 2026-09-11T19:42:36Z Persino 2851 /* Funkcje, z funkcją parametrów, z tablicią ramki lub one z podtablicą {{Code|args}} */ 555743 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykłąd wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> p7na5dwd30jokcjbhslyb3cxir8exgq 555744 555743 2026-09-11T19:43:12Z Persino 2851 /* Przykłąd wywołania funkcji z wartością nietablicową */ 555744 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> ==== Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9rpl6vw0s3fau2m6xi9w70vrrzbhohx 555745 555744 2026-09-11T19:44:53Z Persino 2851 /* = Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa */ 555745 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartośc zwracanainumer metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3tg0lcb72oj9hxyx5lcy47d3ehg008f 555746 555745 2026-09-11T19:46:43Z Persino 2851 /* Wartośc zwracanainumer metody */ 555746 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> dk9o4j0m3elrakdriidf51phdwkwqe9 555747 555746 2026-09-11T19:47:25Z Persino 2851 /* Opis zwracanych elementów przez funkcję zwracaną - różnemetody zwracania, jak je wykorzystać */ 555747 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 94ko1nklpljvp98ys6nyqu7hwwcrvd4 555748 555747 2026-09-11T19:51:27Z Persino 2851 /* Omówienie pobierania takich parmetrów */ 555748 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nciakgkdu4ym1wdo0kjw2qeja6x7a2z 555749 555748 2026-09-11T19:54:08Z Persino 2851 /* Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} */ 555749 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cjdbzhjgdhea6m8jbpfhowp66x55zfh 555750 555749 2026-09-11T19:58:50Z Persino 2851 /* Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru */ 555750 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> j7o8rwetbsims0bzc7li5738fafzhw8 555751 555750 2026-09-11T20:18:24Z Persino 2851 /* Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać */ 555751 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3pm2nnavbcry8nwbajbzuxemwinxrot 555752 555751 2026-09-11T20:20:45Z Persino 2851 /* Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać */ 555752 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry. Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ke70kbv3rpf1r2r06pe4wl83j2ng6p9 555753 555752 2026-09-11T20:57:49Z Persino 2851 /* Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać */ 555753 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gw3e8ujimwxruccmqrzoo86t0vapvac 555754 555753 2026-09-11T20:59:51Z Persino 2851 /* Gdy funkcja ramki istnieje, i gdy: czy_frame_lub_parent, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji ramki parametrów rodzica */ 555754 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> rpsfm4hunjwst3cuteo0na5zhzbylx7 555755 555754 2026-09-11T21:03:13Z Persino 2851 /* Gdy funkcja ramki istnieje, i gdy: czy_frame_lub_parent, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica */ 555755 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> hrp8kll5mmsyvsxtwi43pcpfd3cilui 555756 555755 2026-09-11T21:10:09Z Persino 2851 /* Przykład wywołania z tablicą bez podtablicy args */ 555756 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> pjcpdb29c0dbyctz198trb4pr074sja 555757 555756 2026-09-11T21:14:39Z Persino 2851 /* p.PobierzParametryRamki */ 555757 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == Funkcja służy do pobierania parametrów ramki dziecka, nie rodzica. 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 08x9uugwr9uapgb20xqcp9z1qksbuv3 555758 555757 2026-09-11T21:17:34Z Persino 2851 /* p.PobierzElementNumerowanyZFrameLubTablicy */ 555758 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == Funkcja służy do pobierania parametrów ramki dziecka, nie rodzica. 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}: * które nie musi być tablicą ramki tablicy transportu, tylko moze być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> omfj0ulbf309qis6d6uiyz0owpwggu0 555793 555758 2026-09-12T07:22:35Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} */ 555793 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == Funkcja służy do pobierania parametrów ramki dziecka, nie rodzica. 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}: * które nie musi być tablicą ramki tablicy transportu, tylko może być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty spssób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> c3fumiduq7qskdv2r593bve3ywr4cis 555794 555793 2026-09-12T07:24:40Z Persino 2851 /* Sposoby wywołania funkcji */ 555794 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == Funkcja służy do pobierania parametrów ramki dziecka, nie rodzica. 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}: * które nie musi być tablicą ramki tablicy transportu, tylko może być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty sposób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana i jego druga wartośc w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gag8qyfx8k1jkog5ocdwcdn9tmwkcka 555798 555794 2026-09-12T11:05:57Z Persino 2851 /* Wartość zwracana i jego druga wartośc w postaci numeru metody */ 555798 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}} Są tutaj przedstawione funkcje parametrów. == {{Code|p.PobierzFrameEwentualnieParent}} == 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 nieistniejący element {{Code|getParent}}, który ma prawo nie być. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} === Sterowanie funkcją === Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. ==== Przykłady wykorzystania z parametrem sterującym ==== 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. === Pobieranie oryginalnej tablicy === 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> === Możliwość tej samej funkcji uruchomioną w ramce lub z podaniem do niej pewnego zestawu parametrów w postaci tablicy === 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> === Niedogodności stosowania z funkcji === Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskany element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. == {{Code|p.PobierzArgsParametry}} == Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica transportu ramki. | 2 = {{Code|czy_nie_tablica_jako_tablica}} | _2 = Czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. }} === Opis działania === 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. === Przykład wywołania funkcji z funkcją parametrów === 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> ==== Użycie funkcji parametrów ==== 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. === Wykorzystanie fukcji w różnych sytuacjach === ; Przypadek pierwszy{{dk}} 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> ; Drugi przypadek{{dk}} 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> === Usunięcie niedogodności === Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === Parametr funkcji nietablicowy === 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> === Brak parametrów funkcji === 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> === Zmienna {{Code|args}} - alternatywny przypadek dla wartości tablicowych niż te bez drugiego parametru === Widzimy, że wtedy zmienna {{Code|args}} jest normalną, niekoniecznie niepusta, tablicą, i nie musimy wtedy wcale pisać drugiego parametru w tej fubkcji, 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> === Różnica drugiego parametru w przypadku wartości nietablicowych === Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> == {{Code|p.PobierzParametryRamki}} == Funkcja służy do pobierania parametrów ramki dziecka, nie rodzica. 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 omawianej funkcji, która jest zwracana przez omawianą funkcję, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju zmiennej {{Code|frame}}, która może być tabelką, ale nie musi być. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych, może że, * tabel (dokładnie, która ta może tabelka to zależy od formatu tej naszej rozważanej zmiennej), * a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> === Funkcje, z funkcją parametrów, z tablicą ramki lub one z podtablicą {{Code|args}} === To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> ==== Przykład wywołania funkcji z funkcją parametrów z tablicą {{Code|args}} ==== Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. ==== Przykład wywołania z tablicą bez podtablicy {{Code|args}} ==== 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> ==== Przykład wywołania funkcji z wartością nietablicową ==== 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> === Wywołania funkcji parametrów bez argumentów - wiele kolejnych wywołań jednocześnie === Wtedy w tej ramce w celu uzyskania, jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === Dwa przypadki, parametr w tablicy, lub wartość nietablicowa funkcji === 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> === Przypadek, gdy parametr funkcji nie jest tablicą === 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> === Omówienie przypadku istnienia tego samego wariantu zmiennej raz podtablicą, a raz jako zmienna nietablicowa === * Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, * lub może być jedyną wartością, którą jest {{Code|frame}}, jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ** ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. === Jakma liczyć element funkcji w przypadku różnych jej parametrów === 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"]}}. === Parametry alternatywne funkcji - przykład wykorzystania funkcji parametrów === 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}}, jeśli tą wartością jest, gdy {{Code|frame{{=}}nil}}, * w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. == {{Code|p.PobierzElementNumerowanyZFrameLubTablicy}} == Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}: * które nie musi być tablicą ramki tablicy transportu, tylko może być innym parametrem, który jest tablicą parametrów podanych do funkcji, * nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki. Ale z drugiej strony, tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. === Sposoby wywołania funkcji === ; Pierwszy sposób{{dk}} Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> ; Drugi sposób{{dk}} A teraz drugi sposób, pisząc, bezpośrednio inaczej, formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> ; Trzeci sposób{{dk}} Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> ; Czwarty sposób{{dk}} Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> ; Piąty sposób{{dk}} Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> === Omówienie pobierania takich parmetrów === A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. === Omówienie sposobów wykorzystywania, robienia tego samego, na różne warianty === * W pierwszym i drugim sposobem zmienną tą nazwijmy to jako {{Code|args}}, jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, * w trzecim sposobie tą zmienną jest cała tablica, * a czwartym jest zestaw parametrów ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> === Ogólny opis stosowania funkcji === Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. === Nazwy alternatywne danych parametrów funkcji ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} === Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji: * jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, * lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, * a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być kolejo do nazw ich odpowiedników nazwanych, które w przykładzie powyżej, mają pierwszeństwo, ale tak nie musi być, te parametry: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru. To stosujemy, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. == {{Code|p.PobierzParametr}} == Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. | 2 = {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} | _2 = Parametry logiczne dodatkowe funkcji. }} === Wartość zwracana, i jego druga wartość w postaci numeru metody === Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. === Opis zwracanych elementów przez funkcję zwracaną - różne metody zwracania, jak je wykorzystać === Ta funkcja zwracana ma w swojej definicji jeszcze inną funkcję, wykorzystaną w nim. To jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}}, i jakie podaliśmy parametry, tzn. czy ona jest tablicą. ==== Gdy funkcja ramki {{Code|pf.getParent}} istnieje lub posiada jego fałszywą definicję ==== Gdy warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli ma wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}). ==== Gdy funkcja ramki istnieje, i gdy: {{Code|czy_frame_lub_parent}}, jest fałszywe, albo ta tablica nie jest ramką, nawet bez fałszywej definicji funkcji fałszywej ramki parametrów rodzica ==== Czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości prawdziwej tego pierwszego podanego parametru, czyli {{Code|true}}, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1]}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). ==== Wartość nietablicowa funkcji parametrów ==== Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. ==== Przypadek nietablicowa wartości, ale nilowej funkcji parametrów ==== Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. ==== Fałszywa funkcja ramki parametrów rodzica ==== Ta funkcja parametrów działa dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. ==== Brak definicji funkcji ramki parametrów rodzica ==== Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. === Nazwy alternatywne parametrów === Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. === Wywołania funkcji w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, z funkcją parametrów === Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> === Przykłady wykorzystania funkcji === ; Przykład pierwszy{{dk}} Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą się parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku według powyższego przykładu raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak ona nie istnieje, to wtedy z: {{Code|pf.args}}. ; Przykład drugi{{dk}} Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. ; Przykład trzeci{{dk}} Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}} poprzez nią. === Przypadek nietablicowego charakteru parametrów funkcji === W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdyby do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np. z ramki, tzn. tablicę ramki funkcji tablicy transportu. === Ogólny przypadek, często stosowany === Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nqr3xu9pdx3zwjioejcdie9doy7xlcq 4 63986 555700 555651 2026-09-11T14:55:18Z Persino 2851 555700 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}} ; Iteratory Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. == {{Code|p.IteratorPoNumerowanychElementachTablicy}} == Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tej tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|t}} | _1 = Tablica, po której iterujemy po elemenetach numerowanych. }} Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} == Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, po której iterujemy. | 2 = {{Code|funkcja}} | _2 = Funkcja sortująca. }} Parametry funkcji zwracanej: {{OpisParametrów | 1 = {{Code|tablica}} | _1 = Tabela operowana. | 2 = {{Code|klucz}} | _2 = Klucz, dzięki któremu szukamy następny element. }} Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> opvh9zolsy2bquue9tq2p7pmpqzk2hm 555701 555700 2026-09-11T14:55:43Z Persino 2851 555701 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}} ; Iteratory Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. == {{Code|p.IteratorPoNumerowanychElementachTablicy}} == Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tej tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|t}} | _1 = Tablica, po której iterujemy po elemenetach numerowanych. }} Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} == Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, po której iterujemy. | 2 = {{Code|funkcja}} | _2 = Funkcja sortująca. }} Parametry funkcji zwracanej: {{OpisParametrów | 1 = {{Code|tablica}} | _1 = Tabela operowana. | 2 = {{Code|klucz}} | _2 = Klucz, dzięki któremu szukamy następny element. }} Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nzza1mfr4baradv2wsv1noe6zho0gt1 555702 555701 2026-09-11T14:57:50Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} */ 555702 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}} ; Iteratory Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. == {{Code|p.IteratorPoNumerowanychElementachTablicy}} == Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tej tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|t}} | _1 = Tablica, po której iterujemy po elemenetach numerowanych. }} Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} == Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane dla nich wartości w pewnej tablicy, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do: {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, po której iterujemy. | 2 = {{Code|funkcja}} | _2 = Funkcja sortująca. }} Parametry funkcji zwracanej: {{OpisParametrów | 1 = {{Code|tablica}} | _1 = Tabela operowana. | 2 = {{Code|klucz}} | _2 = Klucz, dzięki któremu szukamy następny element. }} Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1gz9b9oijdowhlopwpdsgvp06hs1wyd 555705 555702 2026-09-11T15:32:46Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} */ 555705 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}} ; Iteratory Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. == {{Code|p.IteratorPoNumerowanychElementachTablicy}} == Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tej tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|t}} | _1 = Tablica, po której iterujemy po elemenetach numerowanych. }} Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} == Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane dla nich wartości w pewnej tablicy, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do: {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,czy_number,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, po której iterujemy. | 2 = {{Code|czy_number}} | _2 = Czy ma sortować i iterować, tylko po liczbach, domyślnie rosnąco, jeżeli nie podano trzeciego parametru funkcji. | 3 = {{Code|funkcja}} | _2 = Funkcja sortująca. }} Parametry funkcji zwracanej: {{OpisParametrów | 1 = {{Code|tablica}} | _1 = Tabela operowana. | 2 = {{Code|klucz}} | _2 = Klucz, dzięki któremu szukamy następny element. }} Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 37gpi4egpeb4zcxo68ln1rnzqv0huwx 555706 555705 2026-09-11T15:33:04Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} */ 555706 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}} ; Iteratory Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. == {{Code|p.IteratorPoNumerowanychElementachTablicy}} == Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tej tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|t}} | _1 = Tablica, po której iterujemy po elemenetach numerowanych. }} Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} == Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane dla nich wartości w pewnej tablicy, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do: {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,czy_number,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, po której iterujemy. | 2 = {{Code|czy_number}} | _2 = Czy ma sortować i iterować, tylko po liczbach, domyślnie rosnąco, jeżeli nie podano trzeciego parametru funkcji. | 3 = {{Code|funkcja}} | _3 = Funkcja sortująca. }} Parametry funkcji zwracanej: {{OpisParametrów | 1 = {{Code|tablica}} | _1 = Tabela operowana. | 2 = {{Code|klucz}} | _2 = Klucz, dzięki któremu szukamy następny element. }} Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> q9k9dk8cq2543w32vbnc2upwispb6qx 555707 555706 2026-09-11T15:36:28Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} */ 555707 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}} ; Iteratory Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. == {{Code|p.IteratorPoNumerowanychElementachTablicy}} == Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tej tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|t}} | _1 = Tablica, po której iterujemy po elemenetach numerowanych. }} Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} == Iterator służy do iterowania po kolei po zsortowanych kluczach, domyślnie dowolnych, ale z możliwością sortowania tylko po liczbach, po kolei alfabetycznie, którym są przyporządkowane dla nich wartości w pewnej tablicy, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe, i nie tylko. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do: {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,czy_number,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, po której iterujemy. | 2 = {{Code|czy_number}} | _2 = Czy ma sortować i iterować, tylko po liczbach, domyślnie rosnąco, jeżeli nie podano trzeciego parametru funkcji. | 3 = {{Code|funkcja}} | _3 = Funkcja sortująca. }} Parametry funkcji zwracanej: {{OpisParametrów | 1 = {{Code|tablica}} | _1 = Tabela operowana. | 2 = {{Code|klucz}} | _2 = Klucz, dzięki któremu szukamy następny element. }} Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3c8rbf308wy7kdeu1jn92dibtsmyq8v 555708 555707 2026-09-11T15:49:14Z Persino 2851 /* {{Code|p.IteratorPoNumerowanychElementachTablicy}} */ 555708 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}} ; Iteratory Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. == {{Code|p.IteratorPoNumerowanychElementachTablicy}} == Iterator służy do iterowania po kolei po liczbach w pewnych tablicach, używając do tego celu niej, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}, tylko z tą różnicą, że on zwraca tylko jej wartości, bez kluczy, a nie po kolei klucz i jego wartość, jak to robi jego wbudowana wersja. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|t}} | _1 = Tablica, po której iterujemy po elemenetach numerowanych. }} Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} == Iterator służy do iterowania po kolei po zsortowanych kluczach, domyślnie dowolnych, ale z możliwością sortowania tylko po liczbach, po kolei alfabetycznie, którym są przyporządkowane dla nich wartości w pewnej tablicy, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe, i nie tylko. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do: {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,czy_number,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|tabela}} | _1 = Tabela, po której iterujemy. | 2 = {{Code|czy_number}} | _2 = Czy ma sortować i iterować, tylko po liczbach, domyślnie rosnąco, jeżeli nie podano trzeciego parametru funkcji. | 3 = {{Code|funkcja}} | _3 = Funkcja sortująca. }} Parametry funkcji zwracanej: {{OpisParametrów | 1 = {{Code|tablica}} | _1 = Tabela operowana. | 2 = {{Code|klucz}} | _2 = Klucz, dzięki któremu szukamy następny element. }} Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2dj04t0ns60w46abi1zjy162ghdiepg 4 63987 555787 555652 2026-09-12T01:44:25Z Persino 2851 /* p.Max */ 555787 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}} Są tutaj przedstawione funkcje wartości minimalnej i maksymalnej. == {{Code|p.Max}} == Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. == {{Code|p.Min}} == Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9sxxi61v48f8lo4cqq89qqqbuyd1z1g 555788 555787 2026-09-12T01:45:06Z Persino 2851 /* p.Min */ 555788 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}} Są tutaj przedstawione funkcje wartości minimalnej i maksymalnej. == {{Code|p.Max}} == Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. == {{Code|p.Min}} == Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3l5s78xj9a4au40a7320n8ted5vvt4s 555789 555788 2026-09-12T01:46:47Z Persino 2851 /* Funkcja biblioteczna */ 555789 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}} Są tutaj przedstawione funkcje wartości minimalnej i maksymalnej. == {{Code|p.Max}} == Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bezpośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. == {{Code|p.Min}} == Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cvinm2umsttr0vy9fewjozwpvjx5ab6 555790 555789 2026-09-12T01:47:27Z Persino 2851 /* Funkcja biblioteczna */ 555790 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}} Są tutaj przedstawione funkcje wartości minimalnej i maksymalnej. == {{Code|p.Max}} == Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bezpośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. == {{Code|p.Min}} == Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. === Odpowiednik szablonowy === Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby, ale też w różnych jednostkach bezwzględnych, z mianem na końcu, w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. === Funkcja biblioteczna === Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: {{OpisParametrów | 1 = {{Code|frame}} | _1 = Tablica ramki tablicy transportu. }} W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bezpośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy|p=Parametry}}}}, do liczenia parametrów tego obiektu, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> d5fh6h16mk2aiekyu85ur4y83odjgrc 828 64049 555704 553944 2026-09-11T15:23:59Z Persino 2851 555704 Scribunto text/plain require("strict"); local p={}; function p.PowtarzaneElementy(tabela_elementy_tabelowe,element,value) local tab_ile=p.JakiElement(tabela_elementy_tabelowe,element,value); local str_element=""; if(not tab_ile)then str_element=element..(#(tabela_elementy_tabelowe[element])+1).."#"; table.insert(tabela_elementy_tabelowe[element],{value,str_element,}); end; str_element=tab_ile or (str_element..tostring(value)) return str_element,tab_ile; end; function p.NameValue(value,tabela_elementy_tabelowe,funkcja,funkcja2) local parametry_modul=require("Module:Parametry"); if(parametry_modul.TypeTable(value))then local str_funkcja,tab_ile=p.PowtarzaneElementy(tabela_elementy_tabelowe,"tabela",value); if(not tab_ile)then str_funkcja=str_funkcja..p.Table(value,tabela_elementy_tabelowe); end; str_funkcja=funkcja and funkcja(str_funkcja,"table") or str_funkcja; return str_funkcja; elseif(parametry_modul.TypeFunction(value))then local str_funkcja=p.PowtarzaneElementy(tabela_elementy_tabelowe,"funkcja",value); str_funkcja=funkcja and funkcja(str_funkcja,"function") or str_funkcja; return str_funkcja; elseif(parametry_modul.TypeString(value))then local czy_dobrze=funkcja2 and funkcja2(value,"string") or nil; if(not czy_dobrze)then value=p.String(value); value=funkcja and funkcja(value,"string") or value; end; return value; else local value=tostring(value); value=funkcja and funkcja(value,type(value)) or value; return value; end; end; function p.Value(value,tabela_elementy_tabelowe) return p.NameValue(value,tabela_elementy_tabelowe, function(value) return nil; end, function(value) return nil; end ); end; function p.Name(name,tabela_elementy_tabelowe) return p.NameValue(name,tabela_elementy_tabelowe, function(name) return "["..name.."]"; end, function(name) local czy_dobrze=string.match(name,"^[%a_][%w_]*$"); return czy_dobrze; end ); end; function p.String(value,czy_w_cudzyslowy) value=mw.ustring.gsub(value,"\\","\\\\"); value=mw.ustring.gsub(value,"\"","\\\""); local tab={ {"\n","\\n",}, {"\t","\\t",}, {"\r","\\r",}, {"\b","\\b",}, {"\v","\\v",}, {"\f","\\f",}, {"\a","\\a",}, {"\0","\\0",}, }; for _,tab_element in ipairs(tab)do value=mw.ustring.gsub(value,tab_element[1],tab_element[2]); end; if(not czy_w_cudzyslowy)then value="\""..value.."\"";end; return value; end; function p.JakiElement(tabela_elementy_tabelowe,element,value) local name_tab=nil; for a,b in ipairs(tabela_elementy_tabelowe[element])do if(b[1]==value)then name_tab=b[2]; break; end; end; return name_tab; end; function p.Iter(tabelka) local parametry_modul=require("Module:Parametry"); local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabelka,false, function(a,b) if((parametry_modul.TypeNumber(a))and(parametry_modul.TypeNumber(b)))then return (a<b); elseif((parametry_modul.TypeString(a))and(parametry_modul.TypeString(b)))then return (a<b); elseif((parametry_modul.TypeBoolean(a))and(parametry_modul.TypeBoolean(b)))then local a=a and 1 or 0;local b=b and 1 or 0; return (a<b); elseif((parametry_modul.TypeNumber(a))and(parametry_modul.TypeString(b)))then return true; elseif((parametry_modul.TypeBoolean(a))and(parametry_modul.TypeString(b)))then return true; elseif((parametry_modul.TypeBoolean(a))and(parametry_modul.TypeNumber(b)))then return true; elseif((parametry_modul.TypeNumber(b))and(parametry_modul.TypeString(a)))then return false; elseif((parametry_modul.TypeBoolean(b))and(parametry_modul.TypeString(a)))then return false; elseif((parametry_modul.TypeBoolean(b))and(parametry_modul.TypeNumber(a)))then return false; end; end ); return __next,tabelka,nil; end; function p.Pairs(tabelka) local __metatable=getmetatable(tabelka); if(__metatable)then return pairs(tabelka); else return p.Iter(tabelka); end; end; function p.Table(tabelka,tabela_elementy_tabelowe) local parametry_modul=require("Module:Parametry"); local str="\n{\n"; local pokolei=0; local function WyswietlanieTable(tabelka,czy_liczba) local pokolei=0; for name,value in p.Pairs(tabelka) do if(((czy_liczba)and(parametry_modul.TypeNumber(name)))or((not czy_liczba)and(not parametry_modul.TypeNumber(name))))then local name_str=p.Name(name,tabela_elementy_tabelowe); local value_str=p.Value(value,tabela_elementy_tabelowe); if(not czy_liczba)then str=str..name_str.." = "..value_str..",\n"; else if((pokolei)and(name==pokolei+1))then pokolei=pokolei+1; str=str..value_str..",\n"; else pokolei=nil; str=str..name_str.." = "..value_str..",\n"; end; end; end; end; end; WyswietlanieTable(tabelka,true); WyswietlanieTable(tabelka,false); str=str.."}"; return str; end; function p.FormatowanieTabelki(str_tabela,ile_dodane) local ile_klamerek=ile_dodane or 0; local szeregi_modul=require("Module:Szeregi"); str_tabela=szeregi_modul.ZamianaZnakowaLinii(str_tabela, function(linia) local spacje; if(mw.ustring.match(linia,"^{"))then spacje=mw.ustring.rep(" ",ile_klamerek*4); ile_klamerek=ile_klamerek+1; elseif(mw.ustring.match(linia,"^}"))then ile_klamerek=ile_klamerek-1; spacje=mw.ustring.rep(" ",ile_klamerek*4); else spacje=mw.ustring.rep(" ",ile_klamerek*4); end; return (spacje or "")..linia; end); return str_tabela; end; function p.PozycjaZmienna(name,value) local parametry_modul=require("Module:Parametry"); local tabela_elementy_tabelowe={tabela={},funkcja={},}; local str_name=p.Name(name,tabela_elementy_tabelowe); str_name=parametry_modul.TypeTable(name) and p.FormatowanieTabelki(str_name,0) or str_name; local str_value=p.Value(value,tabela_elementy_tabelowe); str_value=parametry_modul.TypeTable(value) and p.FormatowanieTabelki(str_value,0) or str_value; local str=str_name.."="..str_value..";"; return str; end; p["ŹródłoLua"]=function(frame,args) local str=""; for _,__value in ipairs(args)do local name=__value[1]; local value=__value[2]; local pozycja_zmienna=p.PozycjaZmienna(name,value); str=str..((str~="")and "\n" or "")..pozycja_zmienna; end; local tab_znak={ ["="]="{{=}}", ["|"]="{{!}}", ["{"]="{{(}}", ["}"]="{{)}}", ["["]="{{!(}}", ["]"]="{{)!}}", }; str=mw.ustring.gsub(str,"[%=%|%{%}%[%]]",function(znak) return tab_znak[znak] or znak; end) str="{{ŹródłoLua|"..str.."}}"; local wikikod=frame:preprocess{text=str,}; return wikikod; end; return p; a64xmuculx7gl7cz2394mq3hbumop9h 10 64100 555813 553782 2026-09-12T11:56:44Z Persino 2851 /* Ilustracja */ 555813 wikitext text/x-wiki {{Podstrona dokumentacji}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Ilustracja == To jest szablon przykład ilustrujący działanie funkcji {{m|Ramka|MinimalnyNumerSpośródOdpowiednikowychZmiennych}} w dokumentacji modułu {{ld2|Ramka}}.Jest to szablon przykład ilustrujący działanie funkcji {{m|Ramka|MinimalnyNumerSpośródOdpowiednikowychZmiennych}} w dokumentacji modułu {{ld2|Ramka}}. == Przykład == {{Pre start}} {{Code|{{s|Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna{{=}}parametr|numerowane{{=}}|2{{=}}tak|parametr3{{=}}tak|parametr5{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna=parametr|numerowane=|2=tak|parametr3=tak|parametr5=tak}}}} {{Code|{{s|Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna{{=}}parametr|numerowane{{=}}tak|2{{=}}tak|parametr3{{=}}tak|parametr5{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna=parametr|numerowane=tak|2=tak|parametr3=tak|parametr5=tak}}}} {{Pre koniec}} {{BrClear}} <includeonly> {{Kategoria|Szablony, zwykłe, przykładów stron projektu/Ramka}} </includeonly> k2lis7eqsg3jemidenrv705ai2b3c6a 555815 555813 2026-09-12T11:57:59Z Persino 2851 /* Ilustracja */ 555815 wikitext text/x-wiki {{Podstrona dokumentacji}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Ilustracja == To jest szablon przykład ilustrujący działanie funkcji {{m|Ramka|MinimalnyNumerSpośródOdpowiednikowychZmiennych}} w dokumentacji modułu {{ld2|Ramka}}. Jest to szablon przykład ilustrujący działanie funkcji {{m|Ramka|MinimalnyNumerSpośródOdpowiednikowychZmiennych}} w dokumentacji modułu {{ld2|Ramka}}. == Przykład == {{Pre start}} {{Code|{{s|Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna{{=}}parametr|numerowane{{=}}|2{{=}}tak|parametr3{{=}}tak|parametr5{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna=parametr|numerowane=|2=tak|parametr3=tak|parametr5=tak}}}} {{Code|{{s|Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna{{=}}parametr|numerowane{{=}}tak|2{{=}}tak|parametr3{{=}}tak|parametr5{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/Ramka/MinimalnyNumerSpośródOdpowiednikowychZmiennych|zmienna=parametr|numerowane=tak|2=tak|parametr3=tak|parametr5=tak}}}} {{Pre koniec}} {{BrClear}} <includeonly> {{Kategoria|Szablony, zwykłe, przykładów stron projektu/Ramka}} </includeonly> p2qi52y3fths4dyhgurshrecbnyeck5 10 64101 555814 553781 2026-09-12T11:57:37Z Persino 2851 /* Ilustracja */ 555814 wikitext text/x-wiki {{Podstrona dokumentacji}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Ilustracja == To jest szablon przykład ilustrujący działanie funkcji {{m|Ramka|IleJestTakichOdpowiednikowychZmiennych}} w dokumentacji modułu {{ld2|Ramka}}. Jest to szablon przykład ilustrujący działanie funkcji {{m|Ramka|IleJestTakichOdpowiednikowychZmiennych}} w dokumentacji modułu {{ld2|Ramka}}. == Przykład == {{Pre start}} {{Code|{{s|Wikibooks/Przykład/Ramka/IleJestTakichOdpowiednikowychZmiennych|zmienna{{=}}parametr|numerowane{{=}}|parametr1{{=}}tak|2{{=}}tak|parametr3{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/Ramka/IleJestTakichOdpowiednikowychZmiennych|zmienna=parametr|numerowane=|parametr1=tak|2=tak|parametr3=tak}}}} {{Code|{{s|Wikibooks/Przykład/Ramka/IleJestTakichOdpowiednikowychZmiennych|zmienna{{=}}parametr|numerowane{{=}}tak|parametr1{{=}}tak|2{{=}}tak|parametr3{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/Ramka/IleJestTakichOdpowiednikowychZmiennych|zmienna=parametr|numerowane=tak|parametr1=tak|2=tak|parametr3=tak}}}} {{Pre koniec}} {{BrClear}} <includeonly> {{Kategoria|Szablony, zwykłe, przykładów stron projektu/Ramka}} </includeonly> 87n8svloi2v6d4c97b86m2bg4ftbhsn 2 64122 555729 554283 2026-09-11T17:56:56Z Persino 2851 555729 css text/css @media screen{ html.skin-theme-clientpref-night > body .vector-dropdown .vector-dropdown-content{ box-shadow:none; border:1px solid white; } html.skin-theme-clientpref-night > body .vector-page-toolbar-container .vector-dropdown{ border-bottom:1px solid black; } html.skin-theme-clientpref-night > body > .vector-header-container, html.skin-theme-clientpref-night > body > .vector-header-container *{ background-color:black; color:white; border-color:white; } html.skin-theme-clientpref-night > body #pt-userpage-2 a:not(.mw-selflink){ color:white; } html.skin-theme-clientpref-night > body > .mw-page-container, html.skin-theme-clientpref-night > body > .mw-page-container > .mw-page-container-inner{ filter:grayscale(100%); } html.skin-theme-clientpref-night > body.action-view td.diff-deletedline .diffchange, html.skin-theme-clientpref-night > body.action-submit td.diff-deletedline .diffchange{ background: var(--background-color-content-removed,#ffe49c); filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body.action-view td.diff-addedline .diffchange, html.skin-theme-clientpref-night > body.action-submit td.diff-addedline .diffchange{ background: var(--background-color-content-added,#a3d3ff); filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body .imeselector, html.skin-theme-clientpref-night > body .imeselector *{ background-color:black !important; color:white !important; border-color:white !important; filter:invert(0) grayscale(100%); } html.skin-theme-clientpref-night > body .imeselector .uls-ime-more-settings-link{ height: calc( 100% - 6px ); } html.skin-theme-clientpref-night > body .uls-ime-menu-settings-item{ padding-bottom:7px; } html.skin-theme-clientpref-night > body, html.skin-theme-clientpref-night > body > .mw-page-container, html.skin-theme-clientpref-night > body > .mw-page-container *{ color:white !important; background-color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output a:not(.mw-selflink), html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output a:not(.mw-selflink):link, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output a:not(.mw-selflink):visited, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output a:not(.mw-selflink):focus, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output a:not(.mw-selflink):hover, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output a:not(.mw-selflink):active{ color:white !important; background-color:black !important; border-color:white !important; text-decoration: underline !important; } html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_ogólnie_spis a, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_ogólnie_spis a:link, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_ogólnie_spis a:visited, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_ogólnie_spis a:focus, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_ogólnie_spis a:active, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_wykaz a, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_wykaz a:link, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_wykaz a:visited, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_wykaz a:focus, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_wykaz a:active{ text-decoration: none !important; } html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_ogólnie_spis a:hover, html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output .toc_wykaz a:hover{ text-decoration: underline !important; } html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output span[typeof="mw:File"], html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output span[typeof="mw:File"] *, html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output figure[typeof="mw:File"], html.skin-theme-clientpref-night > body > .mw-page-container #mw-content-text .mw-parser-output figure[typeof="mw:File"] *{ background-color:transparent !important; color:unset !important; background-color:unset !important; } html.skin-theme-clientpref-night > body > .mw-page-container .mw-parser-output img, html.skin-theme-clientpref-night > body > .mw-page-container .mw-footer-container img{ filter:invert(100%) grayscale(100%) !important; background-color:transparent !important; } html.skin-theme-clientpref-night > body .vector-pinned-container .vector-toc ul.vector-toc-contents li a, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a, html.skin-theme-clientpref-night > body .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a{ z-index:0 !important; position:relative !important; } html.skin-theme-clientpref-night > body .vector-pinned-container .vector-toc ul.vector-toc-contents li > a:hover, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-toc ul.vector-toc-contents li > a:hover, html.skin-theme-clientpref-night > body .vector-pinned-container .vector-menu ul.vector-menu-content-list li > a:hover, html.skin-theme-clientpref-night > body .vector-unpinned-container .vector-menu ul.vector-menu-content-list li > a:hover{ background-color:black !important; color:white !important; border-color:white !important; z-index:1 !important; position:relative !important; } html.skin-theme-clientpref-night > body #mw-content-text > div.printfooter{ z-index:1; position:relative; } html.skin-theme-clientpref-night > body .mw-footer-container, html.skin-theme-clientpref-night > body .mw-footer-container *, html.skin-theme-clientpref-night > body .vector-menu-heading, html.skin-theme-clientpref-night > body .vector-menu-heading *, html.skin-theme-clientpref-night > body > .mw-page-container div.group > div.tool > div.menu, html.skin-theme-clientpref-night > body > .mw-page-container div.group > div.tool > div.menu *{ color:white !important; background-color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body div.uls-rewrite, html.skin-theme-clientpref-night > body div.uls-rewrite *{ color:white !important; background-color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body > div.uls-menu, html.skin-theme-clientpref-night > body > div.uls-menu *, html.skin-theme-clientpref-night > body > .language-settings-dialog, html.skin-theme-clientpref-night > body > .language-settings-dialog *{ color:white !important; background-color:black !important; border-color:white !important; filter:invert(0%); } html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-highlight, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-indent, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-outdent, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-articleSearch, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-settings, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-puzzle, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-reference, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-image, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-link, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-signature, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-italic, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-bold, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-article, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-previous, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-tag, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-check, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-highlight, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-expand, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-first, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-next, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-last, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-search, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-close, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-menu, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-info, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-bookmark, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-ellipsis, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-listBullet, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-listNumbered, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-code, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-noWikiText, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-newline, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-bigger, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-smaller, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-superscript, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-subscript, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-imageGallery, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-articleRedirect, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-table, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-mathematicsDisplayInline, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-mathematicsDisplayBlock, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-helpNotice, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-edit, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-trash, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-pushPin, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-reload{ color: white !important; background-color: unset !important; border-color: white !important; } html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-sortAscending, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-sortDescending, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-pilcrow, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-wrapping, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-check-all, html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-gotoLine{ color: white !important; background-color: black !important; border-color: white !important; } html.skin-theme-clientpref-night > body .cdx-button__icon.cm-mw-icon--previous, html.skin-theme-clientpref-night > body .cdx-button__icon.cm-mw-icon--next, html.skin-theme-clientpref-night > body .cdx-icon.cdx-icon--medium.cm-mw-icon--match-case, html.skin-theme-clientpref-night > body .cdx-icon.cdx-icon--medium.cm-mw-icon--regexp, html.skin-theme-clientpref-night > body .cdx-icon.cdx-icon--medium.cm-mw-icon--quotes{ filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body span.oo-ui-iconElement-icon.oo-ui-icon-check{ filter:invert(0) grayscale(100%) !important; } html.skin-theme-clientpref-night > body span.vector-icon{ background-color:white !important; } html.skin-theme-clientpref-night > body span.oo-ui-indicatorElement-indicator{ color: white !important; background-color: unset !important; border-color: white !important; } html.skin-theme-clientpref-night > body .mw-tag-wikieditor, html.skin-theme-clientpref-night > body .mw-tag-wikieditor *{ background-color:black !important; color:white !important; border-color:white !important; } html.skin-theme-clientpref-night > body input.oo-ui-inputWidget-input{ color: white !important; background-color: black !important; border-color: white !important; } html.skin-theme-clientpref-night > body > div.uls-menu .oo-ui-iconElement-icon{ background-color:transparent !important; filter:invert(100%) grayscale(100%) !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .uls-sub-panel{ top:0 !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .row .uls-display-settings-tab-switcher, html.skin-theme-clientpref-night > body > .language-settings-dialog .uls-sub-panel{ background-color:transparent !important; border:0 !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .row .uls-display-settings-tab-switcher button, html.skin-theme-clientpref-night > body > .language-settings-dialog .uls-sub-panel button{ background-color:black !important; color:white !important; border-color:white !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .settings-text:hover{ background-color:white!important; color:black !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog .settings-text:not(:hover){ background-color:black!important; color:white !important; } html.skin-theme-clientpref-night > body > .language-settings-dialog #languagesettings-settings-panel{ background-color:transparent !important; } html.skin-theme-clientpref-night > body > .vector-header-container #p-vector-user-menu-userpage a{ font-weight:bolder; } html.skin-theme-clientpref-night > body::selection, html.skin-theme-clientpref-night > body *::selection{ background-color:white !important; color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body::-moz-selection html.skin-theme-clientpref-night > body *::-moz-selection{ background-color:white !important; color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body .cm-scroller .cm-line ::selection, html.skin-theme-clientpref-night > body .cm-scroller .cm-line::selection, html.skin-theme-clientpref-night > body .ͼ4 .cm-line ::selection, html.skin-theme-clientpref-night > body .ͼ4 .cm-line::selection, html.skin-theme-clientpref-night > body .ͼo.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, html.skin-theme-clientpref-night > body .ͼo .cm-selectionBackground, html.skin-theme-clientpref-night > body .ͼo .cm-content ::selection{ background-color:white !important; color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body .cm-scroller .cm-line ::-moz-selection, html.skin-theme-clientpref-night > body .cm-scroller .cm-line::-moz-selection, html.skin-theme-clientpref-night > body .ͼ4 .cm-line ::-moz-selection, html.skin-theme-clientpref-night > body .ͼ4 .cm-line::-moz-selection, html.skin-theme-clientpref-night > body .ͼo.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, html.skin-theme-clientpref-night > body .ͼo .cm-selectionBackground, html.skin-theme-clientpref-night > body .ͼo .cm-content ::-moz-selection{ background-color:white !important; color:black !important; border-color:white !important; } html.skin-theme-clientpref-night > body .ͼo .cm-panels.cm-panels-bottom{ border-top: 1px solid white; } html.skin-theme-clientpref-night > body hr, html.skin-theme-clientpref-night > body > .mw-page-container .cdx-message__icon{ filter:invert(100%) grayscale(100%); } html.skin-theme-clientpref-night > body span.ext-discussiontools-init-replylink-buttons, html.skin-theme-clientpref-night > body span.ext-discussiontools-init-replylink-buttons *{ color:white !important; background-color:black !important; border:0 !important; } html.skin-theme-clientpref-night > body > div.mw-notification-area-overlay .mw-notification-content, html.skin-theme-clientpref-night > body > div.mw-notification-area-overlay .mw-notification-content *{ color:white; background-color:black; border-color:white; filter:invert(0) grayscale(100%); } html.skin-theme-clientpref-night > body > div.mw-notification-area-overlay .mw-notification-content .oo-ui-image-success{ background-color:unset; } html.skin-theme-clientpref-night > body > div.mw-notification-area-overlay .mw-notification-content a{ font-weight:bolder; } html.skin-theme-clientpref-night > body span.link > a, html.skin-theme-clientpref-night > body span.link > a:link, html.skin-theme-clientpref-night > body span.link > a:visited, html.skin-theme-clientpref-night > body span.link > a:hover, html.skin-theme-clientpref-night > body span.link > a:active{ color:white; background-color:black; border-color:none; } html.skin-theme-clientpref-night > body img.mw-logo-icon{ background-color:white; color:black; border-color:black; } html.skin-theme-clientpref-night > body .cdx-checkbox__input:enabled:checked + .cdx-checkbox__icon{ background-color:black; color:white; border-color:white; } html.skin-theme-clientpref-night > body .cdx-button:enabled.cdx-button--weight-quiet:hover{ background-color: gray; mix-blend-mode:unset; } html.skin-theme-clientpref-night > body .uls-language-actions-close, html.skin-theme-clientpref-night > body .uls-settings-block--with-add-languages, html.skin-theme-clientpref-night > body a.mw-logo img, html.skin-theme-clientpref-night > body span.vector-icon img{ filter:invert(100%) grayscale(100%) !important; } html.skin-theme-clientpref-night > body a.mw-logo img.mw-logo-icon{ background-color:white; } html.skin-theme-clientpref-night > body a.mw-logo img.mw-logo-wordmark{ background-color:black; } html.skin-theme-clientpref-night > body a.mw-logo{ background-color:black; } html.skin-theme-clientpref-night > body span.vector-icon{ background-color:white; } html.skin-theme-clientpref-night span.tab > a.skin-invert, html.skin-theme-clientpref-night a.skin-invert.label, html.skin-theme-clientpref-night div.tabs > span > a.skin-invert{ color-scheme:unset !important; filter:none !important; } html.skin-theme-clientpref-night .skin-invert-image img, html.skin-theme-clientpref-night .skin-invert.label::after, html.skin-theme-clientpref-night .skin-invert.current::before, html.skin-theme-clientpref-night .oo-ui-iconElement-icon, html.skin-theme-clientpref-night .oo-ui-indicatorElement-indicator, html.skin-theme-clientpref-night div.tabs > span > a.skin-invert::before, html.skin-theme-clientpref-night label.mw-enhancedchanges-arrow{ color-scheme: light !important; filter: invert(100%) grayscale(100%) !important; } html.skin-theme-clientpref-night > body input[type="radio"], html.skin-theme-clientpref-night > body input[type="checkbox"]{ color-scheme: light !important; filter: invert(1) grayscale(100%) !important; background-color:black; color:white; border-color:white; } html.skin-theme-clientpref-night input[type="radio"] + span.cdx-radio__icon, html.skin-theme-clientpref-night input[type="radio"]:hover + span.cdx-radio__icon{ filter:grayscale(100%) !important; } html.skin-theme-clientpref-night > body .oo-ui-widget, html.skin-theme-clientpref-night > body .oo-ui-widget *{ background-color:black; color:white; border-color:white; filter:invert(0%) grayscale(100%); } div.vector-main-menu > div.mw-portlet > button.uls-settings-trigger, html.skin-theme-clientpref-night > body div#mw-abusefilter-examine-editor, html.skin-theme-clientpref-night > body div#mw-abusefilter-examine-editor *, html.skin-theme-clientpref-night > body div#vector-appearance-pinned-container, html.skin-theme-clientpref-night > body div#vector-appearance-pinned-container *, html.skin-theme-clientpref-night > body div#vector-appearance-unpinned-container, html.skin-theme-clientpref-night > body div#vector-appearance-unpinned-container *, html.skin-theme-clientpref-night > body div.mw-rcfilters-container, html.skin-theme-clientpref-night > body div.mw-rcfilters-container *, html.skin-theme-clientpref-night > body div.mw-rcfilters-ui-rcTopSectionWidget-topLinks-top, html.skin-theme-clientpref-night > body div.mw-rcfilters-ui-rcTopSectionWidget-topLinks-top *{ color: white !important; background-color: unset !important; border-color: white !important; } html.skin-theme-clientpref-night > body > div.mw-page-container > div.mw-page-container-inner .mw-highlight > pre{ position:relative; box-shadow:none; } html.skin-theme-clientpref-night > body .mw-search-form-wrapper, html.skin-theme-clientpref-night > body .mw-search-form-wrapper *{ background-color:black !important; color:white !important; border-color:white !important; } html.skin-theme-clientpref-night > body .oo-ui-tagItemWidget{ border-radius:unset !important; height:1.7357em !important; } html.skin-theme-clientpref-night > body .oo-ui-fieldLayout-header{ margin-right:0.4em; } html.skin-theme-clientpref-night > body .oo-ui-buttonElement-framed.oo-ui-widget-enabled > .oo-ui-buttonElement-button{ background:none !important; } html.skin-theme-clientpref-night > body .mw-advancedSearch-fieldContainer, html.skin-theme-clientpref-night > body .mw-search-form-wrapper .mw-advancedSearch-namespace-selection{ background:none !important; } html.skin-theme-clientpref-night > body .oo-ui-checkboxInputWidget [type="checkbox"]{ margin: 1px; width:1.5em; height:1.5em; } html.skin-theme-clientpref-night > body .cdx-popover, html.skin-theme-clientpref-night > body .cdx-popover *, html.skin-theme-clientpref-night > body div.cdx-dialog{ background-color:black !important; color:white !important; border-color:white !important; } html.skin-theme-clientpref-night > body div.cdx-dialog{ filter:invert(0%) grayscale(100%) !important; } html.skin-theme-clientpref-night > body .cdx-popover .mw-special-watchlistlabels-onboarding-image{ filter:invert(0%) grayscale(100%) !important; } html.skin-theme-clientpref-night > body #pasek_postępu, html.skin-theme-clientpref-night > body #pasek_postępu *, html.skin-theme-clientpref-night > body .dymkisubst_link_wewnętrzny_komunikatów, html.skin-theme-clientpref-night > body .dymkisubst_link_wewnętrzny_komunikatów *{ background-color:black !important; color:white !important; border-color:white !important; filter:invert(0%) grayscale(100%); } html.skin-theme-clientpref-night > body .oo-ui-dropdownWidget.oo-ui-widget-disabled .oo-ui-dropdownWidget-handle{ background-color:unset; } html.skin-theme-clientpref-night > body .vector-page-titlebar > .mw-portlet-lang:last-child{ margin-right:0; } } mz5pe1kd9a64e8ohgaukq3prig1voiw 10 64146 555675 555665 2026-09-11T13:13:26Z Persino 2851 555675 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}}Lp. !{{!}}Parametr ! Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}}<div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} colspan{{=}}"2"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> er39mgzm9llpwt8jhd4artizwd8ygx5 555679 555675 2026-09-11T13:17:08Z Persino 2851 555679 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}}Lp. !{{!}}Parametr ! Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}}<div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} colspan{{=}}"2"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> eht8byic3b088x9xcopu1ka3xvg08pi 555690 555679 2026-09-11T13:55:30Z Persino 2851 555690 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}}Lp. !{{!}}Parametr ! Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}}<div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} colspan{{=}}"2"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek?!!{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> kjqa65zad9mn33jf8prbedeji7qk98s 555691 555690 2026-09-11T13:58:25Z Persino 2851 555691 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}}Lp. !{{!}}Parametr ! Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}}<div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} colspan{{=}}"2"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;!nagłówek?!!{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> 9vypvg6lzh6lx3ipq3jj9yhfy9zcps1 555692 555691 2026-09-11T13:58:49Z Persino 2851 555692 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}}Lp. !{{!}}Parametr ! Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}}<div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} colspan{{=}}"2"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;!nagłówek?!{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> f3nn8v5phhuxu6ce9t4nsv8fu7jcf6x 555693 555692 2026-09-11T14:00:42Z Persino 2851 555693 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}}Lp. !{{!}}Parametr ! Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}}<div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} colspan{{=}}"2"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> eht8byic3b088x9xcopu1ka3xvg08pi 555712 555693 2026-09-11T16:01:37Z Persino 2851 555712 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{((}}#if:{{(((}}__{{)))}}{{!}}style="{{(((}}__{{)))}}"{{))}} {{!}} Parametr ! Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} {{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> h16rr0l1n6alup5ebkk5vghptb4abqy 555713 555712 2026-09-11T16:03:58Z Persino 2851 555713 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{__}}}|style="{{{__}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} {{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> s2rremsvrxexypgydzvjjylecu91p4y 555714 555713 2026-09-11T16:06:53Z Persino 2851 555714 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{__}}}|style="{{{__}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} {{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} {{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}__{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}__{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> 0tew34btpi1t2bjove4rj4tdnb3218b 555716 555714 2026-09-11T16:24:38Z Persino 2851 555716 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{__|}}}|style="{{{__}}}"}} {{#if:{{{___|}}}|style="{{{___}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}___{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}___{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}{{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}__{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}__{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> 5pulvf88krngq8mevfcf1kbu8px1ppm 555717 555716 2026-09-11T16:30:33Z Persino 2851 555717 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{__|}}}|style="{{{__}}}"}} {{#if:{{{___|}}}|style="{{{___}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}___{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}___{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}__{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}__{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> az39kdmj49tooy8a0nb6vv3p9m7ro46 555718 555717 2026-09-11T16:36:46Z Persino 2851 555718 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{__|}}}|style="{{{__}}}"}} {{#if:{{{___|}}}|style="{{{___}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}___{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}___{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- -->{{((}}!{{))}} <!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}<!-- -->{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}__{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}__{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> q7tuupdztpbrw4sfavai6cnyxjjd8jk 555719 555718 2026-09-11T16:39:51Z Persino 2851 555719 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{__|}}}|style="{{{__}}}"}} {{#if:{{{___|}}}|style="{{{___}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}___{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}___{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- -->{{((}}!{{))}} <!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}<!-- -->{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}__{{=}}{{!}}___{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}__{{((}}_{{))}}{{=}}{{!}}___{{((}}_{{))}}{{!}}++{{((}}_{{))}}{{=}}{{!}}+++{{((}}_{{))}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> sloc00epe9al6isth6ys66slmzjouo2 555720 555719 2026-09-11T16:44:39Z Persino 2851 555720 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{--|}}}|style="{{{--}}}"}} {{#if:{{{---|}}}|style="{{{---}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}--{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}--{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}---{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}---{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}--{{=}}{{!}}---{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}--{{((}}_{{))}}{{=}}{{!}}---{{((}}_{{))}}{{=}}{{!}}++{{((}}_{{))}}{{=}}{{!}}+++{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> 4mhr9utdpewrnf3etgzxhr52h9kzoa0 555721 555720 2026-09-11T16:47:04Z Persino 2851 555721 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{--|}}}|style="{{{--}}}"}} {{#if:{{{---|}}}|style="{{{---}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}--{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}--{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}---{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}---{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- -->{{((}}!{{))}} <!- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}--{{=}}{{!}}---{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}--{{((}}_{{))}}{{=}}{{!}}---{{((}}_{{))}}{{=}}{{!}}++{{((}}_{{))}}{{=}}{{!}}+++{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> cf3mt51vgv1zhbk6b5uhikylp1dlynw 555722 555721 2026-09-11T16:47:39Z Persino 2851 555722 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{--|}}}|style="{{{--}}}"}} {{#if:{{{---|}}}|style="{{{---}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}--{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}--{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}---{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}---{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- -->{{((}}!{{))}} <!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} {{(((}}_{{((}}_{{))}}{{)))}}{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}--{{=}}{{!}}---{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}--{{((}}_{{))}}{{=}}{{!}}---{{((}}_{{))}}{{=}}{{!}}++{{((}}_{{))}}{{=}}{{!}}+++{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> gn15q7694t53ww4jno55u319d8tucv7 555723 555722 2026-09-11T16:50:07Z Persino 2851 555723 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{--|}}}|style="{{{--}}}"}} {{#if:{{{---|}}}|style="{{{---}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}--{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}--{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}---{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}---{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- -->{{((}}!{{))}} <!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} <div>{{(((}}_{{((}}_{{))}}{{)))}}</div><!-- -->>{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}--{{=}}{{!}}---{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}--{{((}}_{{))}}{{=}}{{!}}---{{((}}_{{))}}{{=}}{{!}}++{{((}}_{{))}}{{=}}{{!}}+++{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> 0twrc0eon92hq64v13m41hnr9033s0e 555724 555723 2026-09-11T16:51:21Z Persino 2851 555724 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{--|}}}|style="{{{--}}}"}} {{#if:{{{---|}}}|style="{{{---}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}} class{{=}}"OpisParametrów-nagłówek"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}--{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}--{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}---{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}---{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- -->{{((}}!{{))}} <!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} <div>{{(((}}_{{((}}_{{))}}{{)))}}</div><!-- -->{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}--{{=}}{{!}}---{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}--{{((}}_{{))}}{{=}}{{!}}---{{((}}_{{))}}{{=}}{{!}}++{{((}}_{{))}}{{=}}{{!}}+++{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> t16qinpyvpr748txpwoha9qzebd2k8k 555727 555724 2026-09-11T17:24:51Z Persino 2851 555727 wikitext text/x-wiki <includeonly><templatestyles src="Szablon:OpisParametrów/styles.css" /> {| class="wikitable OpisParametrów {{{klasa|}}}" {{#if:{{{styl|}}}|style="{{{styl|}}}"}} |- !{{!}} Lp. ! {{#if:{{{--|}}}|style="{{{--}}}"}} {{#if:{{{---|}}}|style="{{{---}}}"}} {{!}} Parametr ! {{!}} Opis {{#invoke:Ramka|Powtarzaj|nie rozwiń=| {{!}}- <!-- -->{{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}<!-- -->class{{=}}"OpisParametrów-nagłówek {{(((}}___{{((}}_{{))}}{{!}}{{)))}}"{{!}}<!-- -->{{((}}#if:{{(((}}___{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}___{{((}}_{{))}}{{)))}}"{{))}}<!-- -->{{))}} <!-- -->{{((}}#if:{{(((}}__{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}__{{((}}_{{))}}{{)))}}"{{))}} {{!}}{{!}} <div>{{((}}_{{))}}</div> ! {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}colspan{{=}}"2"{{))}} <!-- --> {{((}}#if:{{(((}}--{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}--{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}---{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}---{{((}}_{{))}}{{)))}}"{{))}} <!-- -->{{!}} <div>{{(((}}{{((}}_{{))}}{{)))}}</div> {{((}}#if:{{(((}}nagłówek{{((}}_{{))}}{{!}}{{)))}}{{!}}{{!}}<!-- -->{{((}}!{{))}} <!-- --> {{((}}#if:{{(((}}++{{((}}_{{))}}{{!}}{{)))}}{{!}}style{{=}}"{{(((}}++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}#if:{{(((}}+++{{((}}_{{))}}{{!}}{{)))}}{{!}}class{{=}}"{{(((}}+++{{((}}_{{))}}{{)))}}"{{))}} <!-- --> {{((}}!{{))}} <div>{{(((}}_{{((}}_{{))}}{{)))}}</div><!-- -->{{))}}<!-- -->}} |}{{#if:{{{bez dodatkowych sprawdzeń|}}}||{{#invoke:Ramka|Rozwiń|{{((}}#invoke:Sprawdź{{!}}Parametry{{!}}{{=}}problemy-w-szablonie-%s {{((}}(({{))}}Kategoria{{((}}!{{))}}Szablon %s do sprawdzenia{{((}})){{))}}{{!}}klasa{{=}}{{!}}styl{{=}}{{!}}--{{=}}{{!}}---{{=}}{{#invoke:Ramka|Powtarzaj|po kolei=tak|nie rozwiń=tak|{{!}}{{((}}_{{))}}{{=}}txt!{{!}}--{{((}}_{{))}}{{=}}{{!}}---{{((}}_{{))}}{{=}}{{!}}++{{((}}_{{))}}{{=}}{{!}}+++{{((}}_{{))}}{{=}}{{!}}__{{((}}_{{))}}{{=}}{{!}}___{{((}}_{{))}}{{=}}{{!}}nagłówek{{((}}_{{))}}{{=}}txt?;_{{((}}_{{))}}{{!}}_{{((}}_{{))}}{{=}}txt?!;nagłówek{{((}}_{{))}}}}{{))}} }}}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> dzzxilvb6zqt1a7mrkcqf7wp31dcv88 10 64147 555673 555664 2026-09-11T13:09:48Z Persino 2851 555673 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:30%; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ white-space:nowrap; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ white-space:normal; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ fb7hzuzkh2n3j8idr7xgty6d54m5bvb 555674 555673 2026-09-11T13:12:34Z Persino 2851 555674 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:30%; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ width:40%; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ 0aohmivupfyiqhxfrav1w7x1tog8ecg 555677 555674 2026-09-11T13:15:05Z Persino 2851 555677 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:30%; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ width:35%; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ ahp480vy6va6ws3zjlzukp976zasku1 555680 555677 2026-09-11T13:22:44Z Persino 2851 555680 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:30%; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:10rem; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:auto; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ 6f7csx557fb9d40o0y0w7t4s51dysbn 555681 555680 2026-09-11T13:26:07Z Persino 2851 555681 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:30%; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:10rem; width:30%; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:auto; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ 2umlivb5821q4khgjjan2lynf0whb92 555682 555681 2026-09-11T13:27:50Z Persino 2851 555682 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:30%; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:30rem; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:auto; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ 864i4adks6pezawugc1s0ey6vm35zxe 555709 555682 2026-09-11T15:52:47Z Persino 2851 555709 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; min-width:fit-content; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:fit-content; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:30rem; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:auto; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ hc50gmf66sk4khh89pvo8257yfat12h 555710 555709 2026-09-11T15:53:36Z Persino 2851 555710 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; min-width:fit-content; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:max-content; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:30rem; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:auto; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ lg62aj7ipk78kpxuzjqqiloawps8jqh 555711 555710 2026-09-11T15:54:17Z Persino 2851 555711 sanitized-css text/css table.OpisParametrów{ margin-top:0; margin-right:0; margin-left:0; width:100%; box-sizing:border-box; } table.OpisParametrów{ display:flex; flex-direction:row; width:auto; max-width:100%; flex-shrink: 1; border:0; overflow:auto; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th, table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-align:center !important; color:white; background-color:black; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th span.link > a{ text-decoration:underline; } table.OpisParametrów > tbody > tr.OpisParametrów-nagłówek > th code{ color:unset; background-color:unset; } table.OpisParametrów > tbody{ display:table; width:100%; } table.OpisParametrów > tbody > tr:first-child > th:first-child{ width:2%; white-space:nowrap; text-align:center; } table.OpisParametrów > tbody > tr:first-child > th:first-child + th{ width:30%; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child{ text-align:center; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th{ text-align:left; font-weight:normal; } table.OpisParametrów > tbody > tr:first-child ~ tr > td:first-child + th + td{ text-align:left; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:30rem; } @media all and (max-width:745px), all and (max-device-height:745px){ table.OpisParametrów{ display:flex !important; flex-direction:row; width:100%; } table.OpisParametrów, table.OpisParametrów > tbody, table.OpisParametrów > tbody > tr, table.OpisParametrów > tbody > tr > th, table.OpisParametrów > tbody > tr > td{ box-sizing:border-box; } table.OpisParametrów > tbody{ display:flex !important; flex-direction:column; width:100%; } table.OpisParametrów > tbody > tr{ display:flex !important; flex-direction:row; flex-wrap:wrap; width:100%; } table.OpisParametrów > tbody > tr> th:not(:first-child), table.OpisParametrów > tbody > tr> td:not(:first-child){ display:block !important; } table.OpisParametrów > tbody > tr > *:first-child{ max-width:2rem !important; width:100% !important; display:flex !important; flex-direction:column; align-items: stretch; justify-content: center; } table.OpisParametrów > tbody > tr:first-child > *:first-child + *{ max-width:5rem !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~ *{ border-left:0; } table.OpisParametrów > tbody > tr:first-child > *:first-child + * ~*{ max-width:calc( 100% - 2rem - 5rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(:first-child) > *:first-child + *{ max-width:calc( 100% - 2rem) !important; width:100% !important; border-left:0; } table.OpisParametrów > tbody > tr:not(.OpisParametrów-nagłówek):last-child > *:first-child, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child, table.OpisParametrów > tbody > tr > *:first-child + *, table.OpisParametrów > tbody > tr:not(:last-child) > *:first-child + * ~ *{ border-bottom:0; } table.OpisParametrów > tbody > tr > *:first-child + * ~ *{ width:100% !important; } table.OpisParametrów.Opis-Szerokość-1 > tbody > tr:not(.OpisParametrów-nagłówek) > *:first-child + *{ min-width:auto; } } /*{{Kategoria|Szablony - arkusze stylów}}*/ 864i4adks6pezawugc1s0ey6vm35zxe 10 64148 555687 555539 2026-09-11T13:51:43Z Persino 2851 /* Przykład */ 555687 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Ramka}} {{Wysokie ryzyko|częste użycie}} {{Wysokie ryzyko|skomplikowany}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == ; Przykład {{Pre| {{s|OpisParametrów | 1 {{=}} Adres kodowy projektu siostrzanego lub lokalnego polskiego {{s|Code|Wikibooks}}:|nagłówek1{{=}}tak | 2 {{=}} {{s|Code|klucz projektu}} | _2 {{=}} Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 {{=}} {{s|Code|kod projektu}} | _3 {{=}} Kod projektu danego wiki. | 4 {{=}} {{s|Code|kod języka}} | _4 {{=}} kod języka danego wiki. | 5 {{=}} {{s|Code|po polsku}} |_5 {{=}} Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 {{=}} {{s|Code|awaryjnie}} | _6 {{=}} Za pomocą projektu {{s|NS|l{{=}}tak|k{{=}}d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 {{=}} Parametry: {{s|Code|nazwij projektem}} i {{s|Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{s|m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{s|Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7{{=}}tak }} }} ; Wynik {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategorie | Szablony formułujące tabele | Szablony specjalne | Szablony opisów }} </includeonly> 2qqk7q5d10zogmvbzu2mv9wo87qkj73 555688 555687 2026-09-11T13:52:10Z Persino 2851 /* Przykład */ 555688 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Ramka}} {{Wysokie ryzyko|częste użycie}} {{Wysokie ryzyko|skomplikowany}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == ; Przykład {{Pre| {{s|OpisParametrów | 1 {{=}} Adres kodowy projektu siostrzanego lub lokalnego polskiego {{s|Code|Wikibooks}}:|nagłówek1{{=}}tak | 2 {{=}} {{s|Code|klucz projektu}} | _2 {{=}} Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 {{=}} {{s|Code|kod projektu}} | _3 {{=}} Kod projektu danego wiki. | 4 {{=}} {{s|Code|kod języka}} | _4 {{=}} kod języka danego wiki. | 5 {{=}} {{s|Code|po polsku}} |_5 {{=}} Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 {{=}} {{s|Code|awaryjnie}} | _6 {{=}} Za pomocą projektu {{s|NS|l{{=}}tak|k{{=}}d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{s|m|Nazwy/przestrzenie}}. | 7 {{=}} Parametry: {{s|Code|nazwij projektem}} i {{s|Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{s|m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{s|Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7{{=}}tak }} }} ; Wynik {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}:|nagłówek1=tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} |_5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem.|nagłówek7=tak }} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategorie | Szablony formułujące tabele | Szablony specjalne | Szablony opisów }} </includeonly> 7fmk8ss740qksiko5ein9rxstnyv29s 555689 555688 2026-09-11T13:53:39Z Persino 2851 /* Przykład */ 555689 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Ramka}} {{Wysokie ryzyko|częste użycie}} {{Wysokie ryzyko|skomplikowany}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == ; Przykład {{Pre| {{s|OpisParametrów | 1 {{=}} Adres kodowy projektu siostrzanego lub lokalnego polskiego {{s|Code|Wikibooks}}: | nagłówek1 {{=}} tak | 2 {{=}} {{s|Code|klucz projektu}} | _2 {{=}} Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 {{=}} {{s|Code|kod projektu}} | _3 {{=}} Kod projektu danego wiki. | 4 {{=}} {{s|Code|kod języka}} | _4 {{=}} kod języka danego wiki. | 5 {{=}} {{s|Code|po polsku}} | _5 {{=}} Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 {{=}} {{s|Code|awaryjnie}} | _6 {{=}} Za pomocą projektu {{s|NS|l{{=}}tak|k{{=}}d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{s|m|Nazwy/przestrzenie}}. | 7 {{=}} Parametry: {{s|Code|nazwij projektem}} i {{s|Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{s|m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{s|Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 {{=}} tak }} }} ; Wynik {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego {{Code|Wikibooks}}: | nagłówek1 = tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} | _5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}} używa się tak samo jak dla funkcji {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji {{m|Nazwy|NpDane}} musimy skorzystać koniecznie z parametru {{Code|kanoniczna}} z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 = tak }} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategorie | Szablony formułujące tabele | Szablony specjalne | Szablony opisów }} </includeonly> qxrm1s5b4ubm4ty7imzqzcf1jirn49x 555698 555689 2026-09-11T14:39:15Z Persino 2851 /* Przykład */ 555698 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Ramka}} {{Wysokie ryzyko|częste użycie}} {{Wysokie ryzyko|skomplikowany}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == ; Przykład {{Pre| {{s|OpisParametrów | 1 {{=}} Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{s|Code|Wikibooks}}: | nagłówek1 {{=}} tak | 2 {{=}} {{s|Code|klucz projektu}} | _2 {{=}} Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 {{=}} {{s|Code|kod projektu}} | _3 {{=}} Kod projektu danego wiki. | 4 {{=}} {{s|Code|kod języka}} | _4 {{=}} kod języka danego wiki. | 5 {{=}} {{s|Code|po polsku}} | _5 {{=}} Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 {{=}} {{s|Code|awaryjnie}} | _6 {{=}} Za pomocą projektu {{s|NS|l{{=}}tak|k{{=}}d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{s|m|Nazwy/przestrzenie}}. | 7 {{=}} Parametry: {{s|Code|nazwij projektem}} i {{s|Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{s|m|Nazwy|NpDane}}, musimy skorzystać koniecznie z parametru: {{s|Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 {{=}} tak }} }} ; Wynik {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{Code|Wikibooks}}: | nagłówek1 = tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} | _5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{m|Nazwy|NpDane}}, musimy skorzystać koniecznie z parametru: {{Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 = tak }} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategorie | Szablony formułujące tabele | Szablony specjalne | Szablony opisów }} </includeonly> rqpjw8iloundhpzm0xmj62mduokb859 555699 555698 2026-09-11T14:41:55Z Persino 2851 /* Przykład */ 555699 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Ramka}} {{Wysokie ryzyko|częste użycie}} {{Wysokie ryzyko|skomplikowany}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == ; Przykład {{Pre| {{s|OpisParametrów | 1 {{=}} Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{s|Code|Wikibooks}}: | nagłówek1 {{=}} tak | 2 {{=}} {{s|Code|klucz projektu}} | _2 {{=}} Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 {{=}} {{s|Code|kod projektu}} | _3 {{=}} Kod projektu danego wiki. | 4 {{=}} {{s|Code|kod języka}} | _4 {{=}} kod języka danego wiki. | 5 {{=}} {{s|Code|po polsku}} | _5 {{=}} Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 {{=}} {{s|Code|awaryjnie}} | _6 {{=}} Za pomocą projektu {{s|NS|l{{=}}tak|k{{=}}d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{s|m|Nazwy/przestrzenie}}. | 7 {{=}} Parametry: {{s|Code|nazwij projektem}} i {{s|Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{s|m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{s|m|Nazwy|NpDane}}, musimy skorzystać koniecznie z parametru: {{s|Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 {{=}} tak }} }} ; Wynik {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{Code|Wikibooks}}: | nagłówek1 = tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = kod języka danego wiki. | 5 = {{Code|po polsku}} | _5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{m|Nazwy|NpDane}}, musimy skorzystać koniecznie z parametru: {{Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 = tak }} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategorie | Szablony formułujące tabele | Szablony specjalne | Szablony opisów }} </includeonly> 8gqadk9nit8yjvbjj8omk7nvha4kb09 555725 555699 2026-09-11T16:52:26Z Persino 2851 /* Przykład */ 555725 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Ramka}} {{Wysokie ryzyko|częste użycie}} {{Wysokie ryzyko|skomplikowany}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Użycie == == Opis parametrów == == Przykład == ; Przykład {{Pre| {{s|OpisParametrów | 1 {{=}} Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{s|Code|Wikibooks}}: | nagłówek1 {{=}} tak | 2 {{=}} {{s|Code|klucz projektu}} | _2 {{=}} Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 {{=}} {{s|Code|kod projektu}} | _3 {{=}} Kod projektu danego wiki. | 4 {{=}} {{s|Code|kod języka}} | _4 {{=}} Kod języka danego wiki. | 5 {{=}} {{s|Code|po polsku}} | _5 {{=}} Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 {{=}} {{s|Code|awaryjnie}} | _6 {{=}} Za pomocą projektu {{s|NS|l{{=}}tak|k{{=}}d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{s|m|Nazwy/przestrzenie}}. | 7 {{=}} Parametry: {{s|Code|nazwij projektem}} i {{s|Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{s|m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{s|m|Nazwy|NpDane}}, musimy skorzystać koniecznie z parametru: {{s|Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 {{=}} tak }} }} ; Wynik {{OpisParametrów | 1 = Adres kodowy projektu siostrzanego lub lokalnego polskiego: {{Code|Wikibooks}}: | nagłówek1 = tak | 2 = {{Code|klucz projektu}} | _2 = Kody języka i projektu podana w jednej zmiennej oddzielone od siebie dwukropkami, może być dowolna liczba tych kodów. | 3 = {{Code|kod projektu}} | _3 = Kod projektu danego wiki. | 4 = {{Code|kod języka}} | _4 = Kod języka danego wiki. | 5 = {{Code|po polsku}} | _5 = Tłumaczy nazwę kanoniczną danej przestrzeni nazw na jej wersję polską, tzn. na język polski, a jeżeli jej wersja polska nie istnieje, to pisze jej wersję w języku angielskim, czyli w postaci nazwy kanonicznej. | 6 = {{Code|awaryjnie}} | _6 = Za pomocą projektu {{NS|l=tak|k=d}} tłumaczy daną nazwę przestrzeni nazw w jednym języku (jej nazwę kanoniczną jakieś przestrzeni nazw) na drugi, gdy wartość jest pusta, to tłumaczy na jej nazwę kanoniczną, jeżeli, przy tym parametrze lub bez, jej wersja w innym danym języku nie istnieje zdefiniowana w module {{m|Nazwy/przestrzenie}}. | 7 = Parametry: {{Code|nazwij projektem}} i {{Code|nazwij dyskusją projektu}}, używa się tak samo jak dla funkcji: {{m|Nazwy|Np}}, tylko z różnicą, że w funkcji: {{m|Nazwy|NpDane}}, musimy skorzystać koniecznie z parametru: {{Code|kanoniczna}}, z wartością niepustą, a wtedy wydrukowane wartości są w postaci wersji kanonicznej w języku angielskim, tak jak z ostatnim szablonem. | nagłówek7 = tak }} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { } } </templatedata> == Zobacz też == {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategorie | Szablony formułujące tabele | Szablony specjalne | Szablony opisów }} </includeonly> pa9743zxqw5oc0t599btcydzp65htnj 14 64150 555795 2026-09-12T07:35:59Z Persino 2851 Utworzono nową stronę „{{Lategoria|Szablony, moduły Lua w Scribunto, z opisami, przykładów stron projektu}}” 555795 wikitext text/x-wiki {{Lategoria|Szablony, moduły Lua w Scribunto, z opisami, przykładów stron projektu}} ar0kmq11kbycmkjn1m3z73hybnhpc0y 555796 555795 2026-09-12T07:36:12Z Persino 2851 555796 wikitext text/x-wiki {{Kategoria|Szablony, moduły Lua w Scribunto, z opisami, przykładów stron projektu}} b6lz6rtgdy8574elh6cxs9mf0u1nnnm 14 64151 555797 2026-09-12T07:37:13Z Persino 2851 Utworzono nową stronę „{{Kategoria|Szablony, moduły Lua w Scribunto, bez opisów, przykładów stron projektu}}” 555797 wikitext text/x-wiki {{Kategoria|Szablony, moduły Lua w Scribunto, bez opisów, przykładów stron projektu}} 37h9jjo3mkpr8t03n0iz5hi6aicw54a 828 64152 555799 2026-09-12T11:13:54Z Persino 2851 Utworzono nową stronę „local p={}; p["Przykład"]=function(frame) 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); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_nienazwanych_…” 555799 Scribunto text/plain local p={}; p["Przykład"]=function(frame) 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); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_nienazwanych_tablicy",liczba_elementow_nienazwanych_tablicy,}, }); return wikikod; end; return p; 2cz2z7jcrfxy344ui95x0zf1tfosgtr 555800 555799 2026-09-12T11:17:31Z Persino 2851 555800 Scribunto text/plain local p={}; p["Przykład"]=function(frame) local tabela={"nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_numerowanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_numerowanych_tablicy",liczba_elementow_numerowanych_tablicy,}, }); return wikikod; end; return p; e972qp2o9ktnkt7bgndnujobppikedi 828 64153 555801 2026-09-12T11:18:27Z Persino 2851 Utworzono nową stronę „local p={}; p["Przykład"]=function(frame) 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); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_nienazwanych_tablicy",liczba_elementow_nie…” 555801 Scribunto text/plain local p={}; p["Przykład"]=function(frame) 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); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_nienazwanych_tablicy",liczba_elementow_nienazwanych_tablicy,}, }); return wikikod; end; return p; in74mql0bj5e9h5irz89t8kdjp7qvcp 828 64154 555802 2026-09-12T11:21:10Z Persino 2851 Utworzono nową stronę „local p={}; p["Przykład"]=function(frame) local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_tablicy",liczba_elementow_tablicy,}, }); return wikikod; end; return p” 555802 Scribunto text/plain local p={}; p["Przykład"]=function(frame) local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_tablicy",liczba_elementow_tablicy,}, }); return wikikod; end; return p 29ffyxobd29ua7m1xszblgsj2oa4ypd 828 64155 555803 2026-09-12T11:24:02Z Persino 2851 Utworzono nową stronę „local p={}; p["Przykład"]=function(frame) 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); local zrodlolua_mo…” 555803 Scribunto text/plain local p={}; p["Przykład"]=function(frame) 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); local zrodlolua_modul=require("Module:ŹródłoLua"); local wikikod=zrodlolua_modul["ŹródłoLua"](frame,{ {"liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy",liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy,}, }); return wikikod; end; return p; 2noql6trbo3qd6kdcw9oa57wfsp6zku 828 64156 555804 2026-09-12T11:26:25Z Persino 2851 Utworzono nową stronę „; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówNienazwanychTablicy/Kod_1|Przykład}}” 555804 wikitext text/x-wiki ; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówNienazwanychTablicy/Kod_1|Przykład}} cb4la6esytvwvj0gpxwou6vty2wmiho 828 64157 555805 2026-09-12T11:28:43Z Persino 2851 Utworzono nową stronę „; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy/Kod_1|Przykład}}” 555805 wikitext text/x-wiki ; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy/Kod_1|Przykład}} ngz2v65efxb1bu3jzaemby3kraci399 828 64158 555806 2026-09-12T11:30:53Z Persino 2851 Utworzono nową stronę „; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówNumerowanychTablicy/Kod_1|Przykład}}” 555806 wikitext text/x-wiki ; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówNumerowanychTablicy/Kod_1|Przykład}} g2t5nqg7tzd6tm3kq4rxde1b4rt8bt6 828 64159 555807 2026-09-12T11:33:33Z Persino 2851 Utworzono nową stronę „; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówTablicy/Kod_1|Przykład}}” 555807 wikitext text/x-wiki ; Przykład, z wykorzystaniem tego modułu, daje wyniki{{dk}} {{#invoke:Wikibooks/Przykład/Parametry/LiczbaElementówTablicy/Kod_1|Przykład}} lgqczhv0z0xpaxmzremj4x7rkjzimx2 14 64160 555809 2026-09-12T11:43:48Z Persino 2851 Utworzono nową stronę „{{Kategoria|Szablony, zwykłe, przykładów stron projektu}}” 555809 wikitext text/x-wiki {{Kategoria|Szablony, zwykłe, przykładów stron projektu}} k0a9633pzcjycwu570hobfyvamwg7w6 10 64161 555810 2026-09-12T11:48:46Z Persino 2851 Utworzono nową stronę „<includeonly>{{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}}</includeonly><noinclude>{{Dokumentacja}}</noinclude>” 555810 wikitext text/x-wiki <includeonly>{{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}}</includeonly><noinclude>{{Dokumentacja}}</noinclude> ikwiu3r6t7eisky5rzv1jfedmlubctg 10 64162 555811 2026-09-12T11:54:04Z Persino 2851 Utworzono nową stronę „{{Podstrona dokumentacji}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Ilustracja == Jest to szablon przykład ilustrujący działanie funkcji {{m|Parametry|LiczbaElementówNumerowanychSzablonu}} w dokumentacji modułu {{ld2|Parametry}}. Jest to szablon przykład ilustrujący działanie funkcji {{m|Parametry|LiczbaElementówNumerowanychSzablonu}} w dokumentacji modułu {{ld2|Parametry}}. == Przykład == {{Pre start}} {{Code|{{s|Wikibooks/Przykład/Parametry/…” 555811 wikitext text/x-wiki {{Podstrona dokumentacji}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Ilustracja == Jest to szablon przykład ilustrujący działanie funkcji {{m|Parametry|LiczbaElementówNumerowanychSzablonu}} w dokumentacji modułu {{ld2|Parametry}}. Jest to szablon przykład ilustrujący działanie funkcji {{m|Parametry|LiczbaElementówNumerowanychSzablonu}} w dokumentacji modułu {{ld2|Parametry}}. == Przykład == {{Pre start}} {{Code|{{s|Wikibooks/Przykład/Parametry/LiczbaElementówNumerowanychSzablonu/Wikikod 1|nazwa1|nazwa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}}}} → {{Tt|{{Wikibooks/Przykład/Parametry/LiczbaElementówNumerowanychSzablonu/Wikikod 1|nazwa1|nazwa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}}}} {{Pre koniec}} {{BrClear}} <includeonly> {{Kategoria|Szablony, zwykłe, przykładów stron projektu/Ramka}} </includeonly> kp6hye3y4sy1gus1z5ixj7oliac80ri 555812 555811 2026-09-12T11:55:17Z Persino 2851 555812 wikitext text/x-wiki {{Podstrona dokumentacji}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Ilustracja == Jest to szablon przykład ilustrujący działanie funkcji {{m|Parametry|LiczbaElementówNumerowanychSzablonu}} w dokumentacji modułu {{ld2|Parametry}}. Jest to szablon przykład ilustrujący działanie funkcji {{m|Parametry|LiczbaElementówNumerowanychSzablonu}} w dokumentacji modułu {{ld2|Parametry}}. == Przykład == {{Pre start}} {{Code|{{s|Wikibooks/Przykład/Parametry/LiczbaElementówNumerowanychSzablonu/Wikikod 1|nazwa1|nazwa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}}}} → {{Tt|{{Wikibooks/Przykład/Parametry/LiczbaElementówNumerowanychSzablonu/Wikikod 1|nazwa1|nazwa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}}}} {{Pre koniec}} {{BrClear}} <includeonly> {{Kategoria|Szablony, zwykłe, przykładów stron projektu/Parametry}} </includeonly> limp0bw34oq0vn0uvwxcvceg8aou8sm