모듈:일본어

설명문서 [편집] [역사] [새로고침]

일본어의 변격 5단 동사를 제외한 품사의 활용을 출력해주는 틀입니다. 시리즈:리브레 일본어 사전에서 사용됩니다. 그 이외에는 실용성이 낮은 것 같습니다.

변격동사는 지원하지 않습니다.

{{일본어 품사 활용|동사|遊|あそ|あそぶ}}
{{일본어 품사 활용|동사|遊|あそ|あそぶ|て}}
{{일본어 품사 활용|동사|遊|あそ|あそぶ|た}}
{{일본어 품사 활용|동사|遊|あそ|あそぶ|ない}}
{{일본어 품사 활용|동사|遊|あそ|あそぶ|ます}}

遊あそぶ

遊あそんで

遊あそんだ

遊あそばない

遊あそびます

{{일본어 품사 활용|동사|押|お|おす}}
{{일본어 품사 활용|동사|押|お|おす|て}}
{{일본어 품사 활용|동사|押|お|おす|た}}
{{일본어 품사 활용|동사|押|お|おす|ない}}
{{일본어 품사 활용|동사|押|お|おす|ます}}

押おす

押おして

押おした

押おさない

押おします

{{일본어 품사 활용|い형|高|たか|たかい}}
{{일본어 품사 활용|い형|高|たか|たかい|て}}
{{일본어 품사 활용|い형|高|たか|たかい|た}}
{{일본어 품사 활용|い형|高|たか|たかい|ない}}
{{일본어 품사 활용|い형|高|たか|たかい|です}}

高たかい

高たかくて

高たかかった

高たかくない

高たかいです

{{일본어 품사 활용|な형|静|しず|しずか|だ}}
{{일본어 품사 활용|な형|静|しず|しずか|て}}
{{일본어 품사 활용|な형|静|しず|しずか|た}}
{{일본어 품사 활용|な형|静|しず|しずか|ない}}
{{일본어 품사 활용|な형|静|しず|しずか|ではない}}
{{일본어 품사 활용|な형|静|しず|しずか|です}}
{{일본어 품사 활용|な형|静|しず|しずか|な}}

静しずかだ

静しずかで

静しずかだった

静しずかじゃない

静しずかではない

静しずかです

静しずかな

모듈:일본어

연습장이나 사용자 문서에서 틀의 사용이나 수정을 연습할 수 있습니다.
분류는 /설명문서에 넣어주세요.

---

local getArgs = require('Module:Arguments').getArgs
local ustring = mw.ustring
local jp = { }
local godan = {
    normal = { "く", "ぐ", "す", "つ", "ぬ", "ぶ", "む", "る", "う" },
    masu = { "き", "ぎ", "し", "ち", "に", "び", "み", "り", "い" },
    te = { "い", "い", "し", "っ", "ん", "ん", "ん", "っ", "っ" },
    teConj = { "て", "で", "て", "て", "で", "で", "で", "て", "て" },
    taConj = { "た", "だ", "た", "た", "だ", "だ", "だ", "た", "た" },
    nai = { "か", "が", "さ", "た", "な", "ば", "ま", "ら", "わ" }
}
local ichidan = { "い", "き", "ぎ", "し", "じ", "ち", "に", "ひ", "び", "み", "り", "え", "け", "げ", "せ", "ぜ", "て", "で", "ね", "へ", "べ", "め", "れ" }

function godan.addTermi (num, conj) -- 어미
    if conj == "て" then return godan.teConj[num]
    elseif conj == "た" then return godan.taConj[num]
    else return conj end
end

function godan.num(kana)
    for i = 1, #godan.normal do
        if godan.normal[i] == kana then
            return i
        end
    end
end

function godan.convert(termination, conj)
    if conj == "て" or conj == "た" then
        for i = 1, #godan.normal do
            if godan.normal[i] == termination then
                return godan.te[i]
            end
        end
    elseif conj == "ます" then
        for i = 1, #godan.normal do
            if godan.normal[i] == termination then
                return godan.masu[i]
            end
        end
    elseif conj == "ない" then--ない
        for i = 1, #godan.normal do
            if godan.normal[i] == termination then
                return godan.nai[i]
            end
        end
    end
end

function jp.ruby(kanji, furigana)
    return "<ruby><rb>"..kanji..[[</rb><rt style{{=}}"font-size: 70%">]]..furigana.."</rt></ruby>"
end

function endofstr( str, i )
    if i then
        return ustring.sub( str, - i, - i)
    else
        return ustring.sub( str, - 1, - 1)
    end
end

function jp.godan_ichidan( str )
    for i = 1, #godan.normal do
        if endofstr( str ) == "る" then
            for i = 1, #ichidan do
                if ichidan[i] == endofstr( str, 2 ) then return "ichidan" end
            end
            return "godan"
        elseif godan.normal[i] == endofstr( str ) then
            return "godan"
        end
    end
end

function jp.noun( kanji, furigana, hiragana, conj )
    if kanji then
        return jp.ruby(kanji, furigana)..conj--"" --오쿠리가나
    else
        return hiragana..conj
    end
end

function jp.i_adject( kanji, furigana, hiragana, conj )
    local return_
    if kanji then
        return_ = jp.ruby(kanji, furigana)..ustring.gsub( hiragana, furigana, "" )--"" --오쿠리가나
    else
        return_ = hiragana
    end
    if conj == nil then
        return return_
    elseif conj == 'です' then
        return return_..conj
    elseif conj == 'ない' then
        return ustring.sub(return_, 1, - 2)..'くない'
    elseif conj == 'た' then
        return ustring.sub(return_, 1, - 2)..'かった'
    elseif conj == 'て' then
        return ustring.sub(return_, 1, - 2)..'くて'
    end
end

function jp.na_adject( kanji, furigana, hiragana, conj )
	local return_
    
    if kanji then
        return_ = jp.ruby(kanji, furigana)..ustring.gsub( hiragana, furigana, "" )--"" --오쿠리가나
    else
        return_ = hiragana
    end
    
	if conj == 'ない' then
        conj = 'じゃない'
    elseif conj == 'た' then
        conj = 'だった'
    elseif conj == 'て' then
        conj = 'で'
    else
    end
    
	return return_..conj
end

function jp.verb( kanji, furigana, hiragana, conj )
    local termination --"" --어미
    local okurigana = ustring.gsub( hiragana, furigana, "" )--"" --오쿠리가나
    local endofhira = endofstr(hiragana)

    if (kanji == "来") then
        if conj == "ない" then
            furigana = "こ"
        else
            furigana = "き"
        end
        return jp.ruby(kanji, furigana)..conj
    end

    if kanji == nil then
	    if conj == nil then
	    	return hiragana
	    else
        	return_ = ustring.sub(hiragana, 1, - 2)
	    end
    elseif ustring.len( hiragana ) > 2 and jp.godan_ichidan(hiragana) == "ichidan" then
        return_ = jp.ruby(kanji, furigana)..ustring.sub(okurigana, 0, - 2 )
    else
        return_ = jp.ruby(kanji, furigana)
    end
    
	if conj == nil then
    	return return_..endofhira
    end
    
    if jp.godan_ichidan(hiragana) == "ichidan" then
		return return_..conj
    
    else
        return return_..godan.convert( endofhira, conj)..godan.addTermi(godan.num(endofhira), conj)
    end
end

function jp.conjugation( frame )
    local args = getArgs(frame)
    local pos = args[1]
	local kanji = args['kanji'] or args[2] --"遊" --한자
    local furigana = args['furigana'] or args[3] -- "あ" --후리가나
    local hiragana = args['hiragana'] or args[4] -- "あそぶ" --히라가나
    local conj = args['conj'] or args[5] --"て" --활용
    if pos == '명사' then
        return jp.noun(kanji, furigana, hiragana, conj)
    elseif pos == 'い형' then
        return jp.i_adject(kanji, furigana, hiragana, conj)
    elseif pos == 'な형' then
        return jp.na_adject(kanji, furigana, hiragana, conj)
    elseif pos == '동사' then
        return jp.verb(kanji, furigana, hiragana, conj)
    end
end

return jp