Type a search term to find related articles by LIMS subject matter experts gathered from the most trusted and dynamic collaboration tools in the laboratory informatics industry.
Modul ini melaksanakan templat {{category handler}}. Templat kategori pengendali membantu templat lain untuk mengautomasikan kedua-dua kategori dan Kategori penyekatan. Untuk maklumat lanjut mengenai menggunakan templat kategori pengendali dalam templat lain, sila lihat template documentation. Teruskan membaca untuk maklumat mengenai menggunakan modul kategori pengendali dalam modul Lua lain, atau untuk maklumat mengenai mengeksport modul ini untuk wiki-wiki lain.
Bagi kes-kes di mana modul yang hanya perlu untuk mengkategorikan di salah satu ruang nama utama (artikel), fail (imej) atau kategori, maka dengan modul ini adalah pembunuhan besar-besaran. Sebaliknya, anda hanya boleh mendapatkan objek tajuk menggunakan mw.title.getCurrentTitle dan periksa lapangan nsText
. Sebagai contoh:
local title = mw.title.getCurrentTitle()
if title.nsText == 'File' then
-- do something
end
Walau bagaimanapun, jika anda memerlukan modul untuk mengkategorikan dalam mana-mana ruang nama lain, maka kami cadangkan anda menggunakan modul ini, kerana ia menyediakan penindasan kategori yang betul dan membuat ia mudah untuk memilih bagaimana untuk mengkategorikan dalam ruang nama yang berbeza.
Modul ini mengesan dan kumpulan semua berbeza Ruang nama digunakan di Wikipedia kepada beberapa jenis. Jenis ini digunakan sebagai nama parameter dalam modul ini.
(tidak termasuk talk
dan other
)
Namespace | Aliases |
---|---|
main
|
|
pengguna
|
user
|
wikipedia
|
project , wp
|
fail
|
file , imej , image
|
mediawiki
|
|
templat
|
template
|
bantuan
|
help
|
kategori
|
category
|
portal
|
|
timedtext
|
|
modul
|
module
|
Modul ini mengambil masa dua atau lebih parameter. Ini adalah contoh menggunakan program dunia hello:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local result = 'Hello world!'
local category = categoryHandler{
'[[Category:Somecat]]',
nocat = frame.args.nocat -- So "nocat=true/false" works
}
category = category or '' -- Check that we don't have a nil value for the category variable.
return result .. category
end
return p
Contoh di atas menggunakan tetapan lalai bagi modul kategori pengendali. Ini bermakna modul contoh yang akan mengkategorikan di muka surat dalam ruang nama berikut:
But it will not categorize in any other namespaces, e.g.:
Dan ia akan tidak mengkategorikan di muka surat disenaraihitamkan. (Lihat seksyen blacklist di bawah.)
Sebab modul kategori pengendali tidak mengkategorikan di beberapa ruang nama adalah bahawa orang-orang dalam ruang nama yang paling modul dan templat hanya menunjukkan atau disenaraikan, tidak digunakan. Oleh itu yang paling modul dan templat tidak mengkategorikan mereka dalam ruang nama.
Mana-mana modul atau templat yang dimaksudkan untuk satu atau lebih dari ruang nama mana modul ini mengkategorikan boleh menggunakan sintaks asas seperti di atas.
Modul ini mengambil masa satu atau lebih parameter dinamakan selepas jenis halaman yang berbeza seperti yang disenaraikan dalam seksyen namespaces di atas. Dengan menggunakan parameter anda boleh menentukan dengan tepat di mana ruang nama templat anda harus mengkategorikan. Seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local result = 'This is a module meant for articles and talk pages.'
local category = categoryHandler{
main = '[[Category:Somecat1]]', -- Categorize in main (article) space
talk = '[[Category:Somecat2]]', -- Categorize in talk space
nocat = frame.args.nocat -- So "nocat=true/false" works
}
category = category or '' -- Check that we don't have a nil value for the category variable.
return result .. category
end
return p
Modul atas hanya akan mengkategorikan di ruang utama dan bercakap. Tetapi ia tidak akan mengkategorikan di muka surat / arkib kerana mereka disenaraihitamkan. (Lihat seksyen blacklist di bawah.) Dan jika anda perlu menunjukkan (berbincang) modul pada talkpage, maka anda boleh memberi makan "nocat='true'
" untuk mengelakkan dari templat yang mengkategorikan. (Lihat seksyen nocat below.) Like this:
== My new module == Hey guys, have you seen my new module? {{#invoke:mymodule|main|nocat=true}} Nice, isn't it? --~~~~
Kadang-kadang kita mahu menggunakan kategori yang sama dalam beberapa ruang nama, kemudian melakukan seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local result = 'This is a module used in several namespaces.'
local category = categoryHandler{
main = '[[Category:Somecat1]]',
[ 1 ] = '[[Category:Somecat2]]', -- For help and user space
help = 1,
user = 1,
talk = '', -- No categories on talk pages
other = '[[Category:Somecat3]]', -- For all other namespaces
nocat = frame.args.nocat -- So "nocat=true/false" works
}
category = category or '' -- Check that we don't have a nil value for the category variable.
return result .. category
end
return p
Dalam contoh di atas kita menggunakan parameter yang bernombor untuk memberi makan salah satu kategori, dan kemudian kita memberitahu modul ini menggunakan parameter yang bernombor untuk kedua-dua bantuan dan ruang pengguna.
Modul kategori pengendali memahami nombor yang tidak terhad parameter bernombor.
lain-lain parameter mentakrifkan apa yang perlu digunakan dalam ruang nama baki yang belum jelas menjadi data diberi makan.
Nota yang kosong tetapi ditakrifkan cakap parameter. Bahawa berhenti modul ini dari menunjukkan apa yang telah diberi makan kepada lain-lain parameter, apabila di ruang cakap.
Modul kategori pengendali juga mempunyai parameter yang dipanggil semua. Ia berfungsi seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local result = 'This is a module used in all namespaces.'
local category = categoryHandler{
all = '[[Category:Somecat1]]', -- Categorize in all namespaces
nocat = frame.args.nocat -- So "nocat=true/false" works
}
category = category or '' -- Check that we don't have a nil value for the category variable.
return result .. category
end
return p
Contoh di atas akan mengkategorikan dalam semua ruang nama, melainkan bukan pada halaman disenaraihitamkan. Jika anda mahu untuk menunjukkan bahawa modul pada laman, kemudian gunakan "nocat=true
" untuk mengelakkan templat dari mengkategorikan.
Kami mencadangkan mengelakkan semua parameter, sejak modul dan templat harus sebaik-baiknya hanya mengkategorikan dalam ruang nama mereka perlu.
Parameter semua juga boleh digabungkan dengan seluruh parameter. Seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local result = 'This is a module used in all namespaces.'
local category = categoryHandler{
all = '[[Category:Somecat1]]', -- Categorize in all namespaces
main = '[[Category:Somecat2]]', -- And add this in main space
other = '[[Category:Somecat3]]', -- And add this in all other namespaces
nocat = frame.args.nocat -- So "nocat=true/false" works
}
category = category or '' -- Check that we don't have a nil value for the category variable.
return result .. category
end
return p
Jika modul di atas diletakkan pada artikel, maka ia akan menambah kategori "Somecat1" dan "Somecat2". Tetapi pada semua jenis lain halaman ia sebaliknya akan menambah "Somecat1" dan "Somecat3". Sebagai contoh yang menunjukkan, yang semua parameter bekerja secara bebas daripada yang lain daripada parameter.
Modul kategori pengendali memahami halaman kecil parameter. Seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local result = 'This is a module used in all namespaces.'
local category = categoryHandler{
subpage = 'no' -- Don't categorize on subpages
wikipedia = '[[Category:Somecat]]',
nocat = frame.args.nocat -- So "nocat=true/false" works
}
category = category or '' -- Check that we don't have a nil value for the category variable.
return result .. category
end
return p
Jika "subpage='no'
" kemudian templat ini tidak akan mengkategorikan pada halaman kecil. Untuk majlis itu jarang berlaku hanya andaingin mengkategorikan pada halaman kecil, kemudian gunakan "subpage='only'
". Jika halaman kecil kosong atau undefined kemudian templat ini mengkategorikan kedua-dua pada petak halaman dan pada halaman kecil.
Modul ini mempunyai senarai hitam di laman-laman dan jenis halaman di mana templat tidak perlu auto-Kategorikan. Oleh itu modul yang menggunakan meta-templat ini kehendak misalnya tidak mengkategorikan di muka surat / arkib dan pada halaman kecil daripada Wikipedia:Template messages.
Jika anda mahu templat untuk mengkategorikan pada halaman yang disenarai hitam, kemudiannya menyuapkan "nocat = false
" untuk modul apabila anda meletakkannya pada halaman, dengan itu melangkau semak senarai hitam. Ambil perhatian bahawa modul ini hanya mengkategorikan jika ia mempunyai data untuk ruang nama itu. Sebagai contoh, jika sintaks asas digunakan (lihat basic usage di atas), maka walaupun anda menetapkan "nocat = false
" templat tidak akan mengkategorikan pada halaman perbualan, kerana ia tidak mempunyai data untuk laman perbincangan. Tetapi ia mempunyai data untuk ruang bantuan, jadi pada laman bantuan disenaraihitamkan ia akan mengkategorikan.
Senarai hitam yang terletak di kotak meja konfigurasi cfg.blacklist
near the top of the module code.
This module understands the nocat parameter:
nocat = true
" then this template does not categorize.nil
then this template categorizes as usual.nocat = false
" this template categorizes even when on blacklisted pages. (See section blacklist above.)true
and false
as defined by Module:Yesno, e.g. "yes", "y", "true", and 1 for true
, and "no", "n", "false", and 0 for false
.Modul dan templat yang menggunakan {{category handler}} hendaklah mengemukakan nocat, supaya mereka juga memahami nocat. kod ini "nocat = frame.args.nocat
" ditunjukkan dalam contoh-contoh di muka surat ini melakukan hal tersebut.
Untuk keserasian ke belakang modul ini juga memahami kategori parameter. Ia berfungsi sama seperti nocat. Seperti ini:
categories = false
" kemudian templat ini telah tidak mengkategorikan.categories = true
" templat ini mengkategorikan walaupun di muka surat disenaraihitamkan.true
and false
sebagaimana yang ditakrifkan oleh Module:Yesno, e.g. "yes", "y", "true", dan 1 dari true
, and "no", "n", "false", dan 0 dari false
.Untuk keserasian ke belakang templat ini jenis menyokong lama "kategori =" parameter. Tetapi nama parameter "kategori" telah digunakan dalam modul ini untuk memberi makan untuk kategori data apabila di ruang kategori. Jadi, ini menggunakan templat kategori2 untuk kegunaan yang sama dengan nocat. Seperti ini:
category2 =
" (kosong tetapi ditakrifkan), atau "category2 = 'no'
", atau jika kategori2 diberi makan apa-apa data yang lain (kecuali seperti yang dinyatakan di dalam kedua-dua mata yang akan datang), maka templat ini telah tidak mengkategorikan.category2 = '¬'
", kemudian templat ini mengkategorikan seperti biasa.category2 = 'yes'
" templat ini mengkategorikan walaupun di muka surat disenaraihitamkan.Selain daripada kategori, anda boleh makan apa-apa lagi untuk modul ini, misalnya beberapa teks. Seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local result = 'This is a module used on talk pages.'
local category = categoryHandler{
talk = '[[Category:Somecat]]',
other = '<p class="error">This module should only be used on talk pages.</p>',
nocat = frame.args.nocat -- So "nocat=true/false" works
}
category = category or '' -- Check that we don't have a nil value for the category variable.
return result .. category
end
return p
Apabila kod modul di atas digunakan pada apa-apa selain daripada halaman perbualan, ia akan kelihatan seperti ini:
This module should only be used on talk pages.
Teks yang tidak akan menunjukkan pada muka surat yang disenarai hitam, jadi tidak menggunakan kaedah ini untuk menunjukkan apa-apa maklumat penting. Pemakanan "nocat = 'true'
" kepada templat yang menyembunyikan teks, sebagaimana ia menyembunyikan apa-apa kategori.
Bagi tujuan ujian dan demonstrasi modul ini boleh mengambil parameter bernama halaman. Seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local category = categoryHandler{
main = 'Category:Some cat',
talk = 'Category:Talk cat',
nocat = frame.args.nocat, -- So "nocat=true/false" works
page = 'User talk:Example'
}
return category
end
return p
Dalam kod di atas kita dengan sengaja meninggalkan daripada kurungan di seluruh nama-nama kategori supaya kita melihat output pada halaman. Tidak kira pada jenis halaman kod di atas digunakan ia akan kembali ini:
halaman parameter membuat berkelakuan modul ini betul-betul seolah-olah pada laman tersebut. Walaupun senarai hitam yang bekerja. Nama halaman yang tidak perlu menjadi halaman yang telah ada.
Jika halaman parameter kosong atau tak ditentukan, nama halaman semasa menentukan hasilnya.
Anda boleh membuatnya begitu modul anda juga memahami halaman parameter. Ini bermakna anda boleh menguji bagaimana templat anda akan mengkategorikan di muka surat yang berbeza, tanpa mempunyai untuk benar-benar mengedit halaman tersebut. Kemudian lakukan seperti ini:
p = {}
local categoryHandler = require( 'Module:Category handler' ).main
function p.main( frame )
local category = categoryHandler{
main = 'Category:Some cat',
talk = 'Category:Talk cat',
nocat = frame.args.nocat, -- So "nocat=true/false" works
page = frame.args.page -- For testing
}
return category
end
return p
Senarai semua parameter:
Perhatikan bahawa nilai kosong kepada parameter "utama" ... "lain-lain" mempunyai makna khas (lihat contoh di atas). Parameter "semua" tidak memahami parameter bernombor, kerana tidak sekali keperluan untuk itu.
Modul ini boleh dieksport ke wiki-wiki lain dengan menukar nilai-nilai dalam konfigurasi kotak meja cfg
. Semua nilai-nilai pembolehubah adalah dikonfigurasikan, jadi selepas nilai konfigurasi telah ditetapkan tidak ada keperluan untuk mengubah kod modul utama. Butiran setiap nilai konfigurasi dimasukkan dalam komen kod modul. Di samping itu, modul ini memerlukan Module:Namespace detect boleh didapati di wiki tempatan.
--------------------------------------------------------------------------------
-- --
-- CATEGORY HANDLER --
-- --
-- This module implements the {{category handler}} template in Lua, --
-- with a few improvements: all namespaces and all namespace aliases --
-- are supported, and namespace names are detected automatically for --
-- the local wiki. This module requires [[Module:Namespace detect]] --
-- and [[Module:Yesno]] to be available on the local wiki. It can be --
-- configured for different wikis by altering the values in --
-- [[Module:Category handler/config]], and pages can be blacklisted --
-- from categorisation by using [[Module:Category handler/blacklist]]. --
-- --
--------------------------------------------------------------------------------
-- Load required modules
local yesno = require('Module:Yesno')
-- Lazily load things we don't always need
local mShared, mappings
local p = {}
--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------
local function trimWhitespace(s, removeBlanks)
if type(s) ~= 'string' then
return s
end
s = s:match('^%s*(.-)%s*$')
if removeBlanks then
if s ~= '' then
return s
else
return nil
end
else
return s
end
end
--------------------------------------------------------------------------------
-- CategoryHandler class
--------------------------------------------------------------------------------
local CategoryHandler = {}
CategoryHandler.__index = CategoryHandler
function CategoryHandler.new(data, args)
local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
-- Set the title object
do
local pagename = obj:parameter('demopage')
local success, titleObj
if pagename then
success, titleObj = pcall(mw.title.new, pagename)
end
if success and titleObj then
obj.title = titleObj
if titleObj == mw.title.getCurrentTitle() then
obj._usesCurrentTitle = true
end
else
obj.title = mw.title.getCurrentTitle()
obj._usesCurrentTitle = true
end
end
-- Set suppression parameter values
for _, key in ipairs{'nocat', 'categories'} do
local value = obj:parameter(key)
value = trimWhitespace(value, true)
obj['_' .. key] = yesno(value)
end
do
local subpage = obj:parameter('subpage')
local category2 = obj:parameter('category2')
if type(subpage) == 'string' then
subpage = mw.ustring.lower(subpage)
end
if type(category2) == 'string' then
subpage = mw.ustring.lower(category2)
end
obj._subpage = trimWhitespace(subpage, true)
obj._category2 = trimWhitespace(category2) -- don't remove blank values
end
return obj
end
function CategoryHandler:parameter(key)
local parameterNames = self._data.parameters[key]
local pntype = type(parameterNames)
if pntype == 'string' or pntype == 'number' then
return self._args[parameterNames]
elseif pntype == 'table' then
for _, name in ipairs(parameterNames) do
local value = self._args[name]
if value ~= nil then
return value
end
end
return nil
else
error(string.format(
'invalid config key "%s"',
tostring(key)
), 2)
end
end
function CategoryHandler:isSuppressedByArguments()
return
-- See if a category suppression argument has been set.
self._nocat == true
or self._categories == false
or (
self._category2
and self._category2 ~= self._data.category2Yes
and self._category2 ~= self._data.category2Negative
)
-- Check whether we are on a subpage, and see if categories are
-- suppressed based on our subpage status.
or self._subpage == self._data.subpageNo and self.title.isSubpage
or self._subpage == self._data.subpageOnly and not self.title.isSubpage
end
function CategoryHandler:shouldSkipBlacklistCheck()
-- Check whether the category suppression arguments indicate we
-- should skip the blacklist check.
return self._nocat == false
or self._categories == true
or self._category2 == self._data.category2Yes
end
function CategoryHandler:matchesBlacklist()
if self._usesCurrentTitle then
return self._data.currentTitleMatchesBlacklist
else
mShared = mShared or require('Module:Category handler/shared')
return mShared.matchesBlacklist(
self.title.prefixedText,
mw.loadData('Module:Category handler/blacklist')
)
end
end
function CategoryHandler:isSuppressed()
-- Find if categories are suppressed by either the arguments or by
-- matching the blacklist.
return self:isSuppressedByArguments()
or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
end
function CategoryHandler:getNamespaceParameters()
if self._usesCurrentTitle then
return self._data.currentTitleNamespaceParameters
else
if not mappings then
mShared = mShared or require('Module:Category handler/shared')
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
end
return mShared.getNamespaceParameters(
self.title,
mappings
)
end
end
function CategoryHandler:namespaceParametersExist()
-- Find whether any namespace parameters have been specified.
-- We use the order "all" --> namespace params --> "other" as this is what
-- the old template did.
if self:parameter('all') then
return true
end
if not mappings then
mShared = mShared or require('Module:Category handler/shared')
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
end
for ns, params in pairs(mappings) do
for i, param in ipairs(params) do
if self._args[param] then
return true
end
end
end
if self:parameter('other') then
return true
end
return false
end
function CategoryHandler:getCategories()
local params = self:getNamespaceParameters()
local nsCategory
for i, param in ipairs(params) do
local value = self._args[param]
if value ~= nil then
nsCategory = value
break
end
end
if nsCategory ~= nil or self:namespaceParametersExist() then
-- Namespace parameters exist - advanced usage.
if nsCategory == nil then
nsCategory = self:parameter('other')
end
local ret = {self:parameter('all')}
local numParam = tonumber(nsCategory)
if numParam and numParam >= 1 and math.floor(numParam) == numParam then
-- nsCategory is an integer
ret[#ret + 1] = self._args[numParam]
else
ret[#ret + 1] = nsCategory
end
if #ret < 1 then
return nil
else
return table.concat(ret)
end
elseif self._data.defaultNamespaces[self.title.namespace] then
-- Namespace parameters don't exist, simple usage.
return self._args[1]
end
return nil
end
--------------------------------------------------------------------------------
-- Exports
--------------------------------------------------------------------------------
local p = {}
function p._exportClasses()
-- Used for testing purposes.
return {
CategoryHandler = CategoryHandler
}
end
function p._main(args, data)
data = data or mw.loadData('Module:Category handler/data')
local handler = CategoryHandler.new(data, args)
if handler:isSuppressed() then
return nil
end
return handler:getCategories()
end
function p.main(frame, data)
data = data or mw.loadData('Module:Category handler/data')
local args = require('Module:Arguments').getArgs(frame, {
wrappers = data.wrappers,
valueFunc = function (k, v)
v = trimWhitespace(v)
if type(k) == 'number' then
if v ~= '' then
return v
else
return nil
end
else
return v
end
end
})
return p._main(args, data)
end
return p