Module:Arguments/doc/tr

Bu modül, {{#invoke:...}} üzerinden iletilen argümanların kolay işlenmesini sağlar. Diğer modüller tarafından kullanılması amaçlanan bir meta modüldür ve doğrudan {{#invoke:...}}'tan çağrılmamalıdır. Özellikleri şunları içerir:

• Bağımsız değişkenlerin kolay kırpılması ve boş argümanların kaldırılması.
• Bağımsız değişkenler hem geçerli çerçeve hem de ana çerçeve tarafından aynı anda iletilebilir. (Daha fazla ayrıntı aşağıda.)
• Bağımsız değişkenler doğrudan başka bir Lua modülünden veya hata ayıklama konsolundan aktarılabilir.
• Bağımsız değişkenler gerektiği gibi getirilir ve bu, ‎<ref> etiketleriyle ilgili (bazı) sorunların önlenmesine yardımcı olabilir.
• Çoğu özellik özelleştirilebilir.

Temel kullanım

İlk önce modülü yüklemeniz gerekir. getArgs adlı bir işlev içerir.

local getArgs = require('Module:Arguments').getArgs

En temel senaryoda, ana işlevinizin içinde getArgs kullanabilirsiniz. args değişkeni, {{#invoke:...}} üzerindeki bağımsız değişkenleri içeren bir tablodur. (Ayrıntılar için aşağıya bakın.)

local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	-- Ana modül kodu buraya gelir.
end

return p

Bununla birlikte, önerilen uygulama, bir işlevi yalnızca {{#invoke:...}} üzerinden bağımsız değişkenleri işlemek için kullanmaktır. Bu, birisi modülünüzü başka bir Lua modülünden çağırırsa, kullanılabilir bir çerçeve nesnesine sahip olmanız gerekmediği anlamına gelir, bu da performansı artırır.

local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	return p._main(args)
end

function p._main(args)
	-- Ana modül kodu buraya gelir.
end

return p

Birden çok işlevin bağımsız değişkenleri kullanmasını istiyorsanız ve bunlara {{#invoke:...}} üzerinden da erişilebilmesini istiyorsanız, bir sarmalayıcı işlevi kullanabilirsiniz.

local getArgs = require('Module:Arguments').getArgs

local p = {}

local function makeInvokeFunc(funcName)
	return function (frame)
		local args = getArgs(frame)
		return p[funcName](args)
	end
end

p.func1 = makeInvokeFunc('_func1')

function p._func1(args)
	-- İlk işlevin kodu buraya gelir.
end

p.func2 = makeInvokeFunc('_func2')

function p._func2(args)
	-- İkinci işlevin kodu buraya gelir.
end

return p

Seçenekler

Aşağıdaki seçenekler mevcuttur. Aşağıdaki bölümlerde açıklanmıştır.

local args = getArgs(frame, {
	trim = false,
	removeBlanks = false,
	valueFunc = function (key, value)
		-- Bir bağımsız değişkeni işlemek için kod
	end,
	frameOnly = true,
	parentOnly = true,
	parentFirst = true,
	wrappers = {
		'Template:A wrapper template',
		'Template:Another wrapper template'
	},
	readOnly = true,
	noOverwrite = true
})

Boşlukların kırpılması ve çıkarılması

Boş bağımsız değişkenler genellikle MediaWiki şablonlarını Lua'ya dönüştürmeye yeni başlayan kodlayıcıları tetikler. Şablon sözdiziminde, boş dizeler ve yalnızca boşluklardan oluşan dizeler false kabul edilir. Bununla birlikte, Lua'da boş dizeler ve boşluklardan oluşan dizeler true kabul edilir. Bu, Lua modüllerinizi yazarken bu tür bağımsız değişkenlere dikkat etmezseniz, aslında false olarak ele alınması gereken bir şeyi true olarak değerlendirebileceğiniz anlamına gelir. Bunu önlemek için, varsayılan olarak bu modül tüm boş argümanları kaldırır.

Benzer şekilde boşluk, konumsal argümanlarla uğraşırken sorunlara neden olabilir. {{#invoke:...}} öğesinden gelen adlandırılmış bağımsız değişkenler için boşluklar kırpılsa da, konumsal bağımsız değişkenler için korunur. Çoğu zaman bu ek boşluk istenmez, bu nedenle bu modül varsayılan olarak onu keser.

Bununla birlikte, bazen girdi olarak boş bağımsız değişkenler kullanmak istersiniz ve bazen ek boşluklar tutmak istersiniz. Bu, bazı şablonları tam olarak yazıldıkları gibi dönüştürmek için gerekli olabilir. Bunu yapmak istiyorsanız, trim ve removeBlanks bağımsız değişkenlerini false olarak ayarlayabilirsiniz.

local args = getArgs(frame, {
	trim = false,
	removeBlanks = false
})

Bağımsız değişkenlerin özel biçimlendirmesi

Bazen bazı boş bağımsız değişkenleri kaldırmak isterken diğerlerini değil, belki de tüm konumsal bağımsız değişkenleri küçük harfle yazmak isteyebilirsiniz. Bunun gibi şeyler yapmak için valueFunc seçeneğini kullanabilirsiniz. Bu seçeneğin girdisi, key ve value olmak üzere iki parametre alan ve tek bir değer döndüren bir işlev olmalıdır. Bu değer, args tablosundaki key alanına eriştiğinizde elde edeceğiniz değerdir.

Örnek 1: Bu işlev, ilk konumsal bağımsız değişken için boşluğu korur, ancak diğer tüm bağımsız değişkenleri kırpar ve diğer tüm boş bağımsız değişkenleri kaldırır.

local args = getArgs(frame, {
	valueFunc = function (key, value)
		if key == 1 then
			return value
		elseif value then
			value = mw.text.trim(value)
			if value ~= '' then
				return value
			end
		end
		return nil
	end
})

Örnek 2: Bu işlev, boş bağımsız değişkenleri kaldırır ve tüm argümanları küçük harfe dönüştürür, ancak boşlukları konum parametrelerinden kırpmaz.

local args = getArgs(frame, {
	valueFunc = function (key, value)
		if not value then
			return nil
		end
		value = mw.ustring.lower(value)
		if mw.ustring.find(value, '%S') then
			return value
		end
		return nil
	end
})

string veya nil türünde olmayan girdi geçirilirse yukarıdaki işlevler başarısız olur.

Modülünüzün ana işlevinde getArgs işlevini kullanırsanız ve bu işlev başka bir Lua modülü tarafından çağrılırsa durum böyle olabilir. Bu durumda, girişinizin türünü kontrol etmeniz gerekecektir.

Özellikle {{#invoke:...}} bağımsız değişkenleri için bir işlev kullanıyorsanız (yani, p.main ve p._main işlevleriniz veya benzeri bir şeye sahipseniz) bu bir sorun değildir.

Tür denetimli Örnek 1 ve 2

Örnek 1: local args = getArgs(frame, { valueFunc = function (key, value) if key == 1 then return value elseif type(value) == 'string' then value = mw.text.trim(value) if value ~= '' then return value else return nil end else return value end end }) Örnek 2: local args = getArgs(frame, { valueFunc = function (key, value) if type(value) == 'string' then value = mw.ustring.lower(value) if mw.ustring.find(value, '%S') then return value else return nil end else return value end end })

Ayrıca, valueFunc işlevinin, args tablosundan bir bağımsız değişken istendiğinde aşağı yukarı çağrıldığını lütfen unutmayın. Bu nedenle performansı önemsiyorsanız, kodunuzla verimsiz bir şey yapmadığınızdan emin olmalısınız.

Çerçeveler ve üst çerçeveler

args tablosundaki bağımsız değişkenler, aynı anda geçerli çerçeveden veya onun üst çerçevesinden geçirilebilir. Bunun ne anlama geldiğini anlamak için bir örnek vermek en kolay yoldur. Diyelim ki Module:ExampleArgs adında bir modülümüz var. Bu modül, iletildiği ilk iki konumsal argümanı yazdırır.

Module:ExampleArgs kodu
local getArgs = require('Module:Arguments').getArgs local p = {} function p.main(frame) local args = getArgs(frame) return p._main(args) end function p._main(args) local first = args[1] or '' local second = args[2] or '' return first .. ' ' .. second end return p

Module:ExampleArgs daha sonra {{#invoke:ExampleArgs|main|firstInvokeArg}} kodunu içeren Template:ExampleArgs tarafından çağrılır. Bu, "firstInvokeArg" sonucunu üretir.

Şimdi Template:ExampleArgs ile çağırsaydık, aşağıdakiler olurdu:

Kod	Sonuç
{{ExampleArgs}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstInvokeArg secondTemplateArg

Bu davranışı değiştirmek için ayarlayabileceğiniz üç seçenek vardır: frameOnly, parentOnly ve parentFirst. frameOnly öğesini ayarlarsanız, yalnızca geçerli çerçeveden iletilen bağımsız değişkenler kabul edilecektir; parentOnly öğesini ayarlarsanız, yalnızca üst çerçeveden iletilen bağımsız değişkenler kabul edilir; ve parentFirst öğesini ayarlarsanız, bağımsız değişkenler hem geçerli hem de üst çerçevelerden iletilecektir, ancak ana çerçevenin geçerli çerçeveye göre önceliği olacaktır. Template:ExampleArgs açısından sonuçlar:

frameOnly

Kod	Sonuç
{{ExampleArgs}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstInvokeArg

parentOnly

Kod	Sonuç
{{ExampleArgs}}
{{ExampleArgs|firstTemplateArg}}	firstTemplateArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstTemplateArg secondTemplateArg

parentFirst

Kod	Sonuç
{{ExampleArgs}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg}}	firstTemplateArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstTemplateArg secondTemplateArg

1. Hem frameOnly hem de parentOnly seçeneklerini ayarlarsanız, modül {{#invoke:...}} üzerinden hiçbir argüman getirmez. Muhtemelen istediğin bu değil.
2. Bazı durumlarda bir ana çerçeve mevcut olmayabilir, örn. getArgs geçerli çerçeve yerine üst çerçeve geçirilirse. Bu durumda, yalnızca çerçeve bağımsız değişkenleri kullanılacaktır (parentOnly ayarlanmadıkça, bu durumda hiçbir bağımsız değişken kullanılmayacaktır) ve parentFirst ve frameOnly seçeneklerinin hiçbir etkisi olmayacaktır.

Sarmalayıcılar

wrappers seçeneği, sınırlı sayıda şablonu sarmalayıcı şablonlar, yani tek amacı bir modülü çağırmak olan şablonlar olarak belirtmek için kullanılır. Modül, bir sarmalayıcı şablonundan çağrıldığını algılarsa, yalnızca üst çerçevedeki argümanları kontrol eder; aksi takdirde, yalnızca getArgs ile iletilen çerçevedeki bağımsız değişkenleri kontrol eder. Bu, modüllerin her bağımsız değişken araması için hem çerçeveyi hem de ana çerçeveyi kontrol etme zorunluluğuyla ilişkili performans kaybı olmadan {{#invoke:...}} veya bir sarmalayıcı şablonu aracılığıyla çağrılmasına olanak tanır.

Örneğin, {{Navbox}} tek içeriğin (‎<noinclude>...‎</noinclude> etiketlerindeki içerik hariç) {{#invoke:Navbox|navbox}} modülüdür. Bu şablon için doğrudan {{#invoke:...}} ifadesine iletilen argümanları kontrol etmenin bir anlamı yoktur, çünkü orada hiçbir bağımsız değişken belirtilmeyecektir. parentOnly seçeneğini kullanarak {{#invoke:...}} ile iletilen argümanları kontrol etmekten kaçınabiliriz, ancak bunu yaparsak {{#invoke:...}} diğer sayfalardan da çalışmayacaktır. Durum böyle olsaydı, {{#invoke:Navbox|navbox|text=Bazı metin}} kodundaki |text=Bazı metin hangi sayfadan kullanılmış olursa olsun tamamen göz ardı edilebilir. Template:Navbox şablonu sarmalayıcı olarak belirtmek için wrappers seçeneğini kullanarak, {{#invoke:Navbox|main|text=Bazı metin}} çoğu sayfadan çalıştırabiliriz, ancak yine de modülün Template:Navbox sayfasındaki bağımsız değişkenleri kontrol etmesini gerektirmeyiz.

Sarmalayıcılar bir dize olarak veya bir dizeler dizisi olarak belirtilebilir.

local args = getArgs(frame, {
	wrappers = 'Template:Wrapper template'
})

local args = getArgs(frame, {
	wrappers = {
		'Template:Wrapper 1',
		'Template:Wrapper 2',
		-- Buraya herhangi bir sayıda sarmalayıcı şablonu eklenebilir.
	}
})

1. Modül, bir sarmalayıcı şablonunun /sandbox alt sayfasından çağrıldığını otomatik olarak algılayacaktır, bu nedenle korumalı alan sayfalarını açıkça belirtmeye gerek yoktur.
2. wrappers seçeneği, frameOnly ve parentOnly seçeneklerinin varsayılanını etkili bir şekilde değiştirir. Örneğin, parentOnly, wrappers ayarlı olarak açıkça false olarak ayarlanmışsa, sarmalayıcı şablonları aracılığıyla yapılan çağrılar hem çerçeve hem de ana bağımsız değişkenlerin yüklenmesine neden olur, ancak sarmalayıcı şablonlar aracılığıyla olmayan çağrılar yalnızca çerçeve bağımsız değişkenleriyle sonuçlanır.
3. wrappers seçeneği ayarlanmışsa ve ana çerçeve yoksa, modül her zaman getArgs ile iletilen çerçeveden argümanları alır.

args tablosuna yazmak

Bazen args tablosuna yeni değerler yazmak faydalı olabilir. Bu, bu modülün varsayılan ayarlarıyla mümkündür. (Bununla birlikte, yeni değerlerinizle yeni bir tablo oluşturmanın ve gerektiğinde args tablosundan bağımsız değişkenleri kopyalamanın genellikle daha iyi bir kodlama stili olduğunu unutmayın.)

args.foo = 'bazı değer'

Bu davranışı readOnly ve noOverwrite seçenekleriyle değiştirmek mümkündür. readOnly ayarlanırsa, args tablosuna herhangi bir değer yazmak mümkün değildir. noOverwrite ayarlanırsa, tabloya yeni değerler eklemek mümkündür, ancak {{#invoke:...}} üzerinden iletilen herhangi bir bağımsız değişkenin üzerine yazılacaksa bir değer eklemek mümkün değildir.

Ref etikletleri

Bu modül, {{#invoke:...}} üzerinden bağımsız değişkenler almak için meta tablolar kullanır. Bu, pairs() işlevini kullanmadan hem çerçeve bağımsız değişkenlerine hem de üst çerçeve bağımsız değişkenlerine erişim sağlar. Bu, modülünüzün giriş olarak ‎<ref> etiketleri geçirilebilmesi durumunda yardımcı olabilir.

‎<ref> etiketlerine Lua'dan erişilir erişilmez, bunlar MediaWiki yazılımı tarafından işlenir ve kaynakça, maddenin altındaki kaynakça listesinde görünecektir. Modülünüz kaynak etiketini çıktıdan çıkarmaya devam ederse, sonunda bir hayali referans elde edersiniz. Bu, modüller mevcut her bağımsız değişkeni otomatik olarak işlediğinden, çerçeveden mi yoksa üst çerçeveden mi bağımsız değişkenlerin kullanılacağını saptamak için pairs() kullanan modüllerde bir sorun olmuştur.

Bu modül, hem çerçeve hem de üst çerçeve argümanlarına erişime izin vererek bu sorunu çözerken, yine de yalnızca gerekli olduğunda bu argümanları getirir. Bununla birlikte, modülünüzün başka bir yerinde pairs(args) kullanırsanız sorun yine de ortaya çıkacaktır.

Bilinen sınırlamalar

Meta tablo kullanımının dezavantajları da vardır. Normal Lua tablo araçlarının çoğu, # işlemi, next() işlevi ve table kitaplığındaki işlevler dahil olmak üzere args tablosunda düzgün çalışmaz. Bunları kullanmak modülünüz için önemliyse, bu modül yerine kendi argüman işleme fonksiyonunuzu kullanmalısınız.

Denemeler

Test Status

Module:Arguments	success: 51, error: 0, skipped: 0
Module:Arguments/sandbox	success: 51, error: 0, skipped: 0

• See test cases
• Diff sandbox code