최신판 |
당신의 편집 |
1번째 줄: |
1번째 줄: |
| local getArgs = require('Module:Arguments').getArgs
| |
| local ustring = mw.ustring
| |
|
| |
| local str = {} | | local str = {} |
|
| |
|
| -- string.find
| |
| function str.len( frame ) | | function str.len( frame ) |
| local new_args = str._getParameters( frame.args, {'s'} )
| | return mw.ustring.len( frame.args.s ) |
| local s = new_args['s'] or ''
| |
| return ustring.len( s )
| |
| end | | end |
| -- string.sub
| | |
| function str.sub( frame ) | | function str.sub( frame ) |
| local args = getArgs(frame)
| | return mw.ustring.sub( frame.args.s, tonumber( frame.args.i ), tonumber( frame.args.j ) ) |
| local new_args = str._getParameters( args, { 's', 'i', 'j' } )
| |
| local s = new_args['s'] or ''
| |
| local i = tonumber( new_args['i'] ) or 1
| |
| local j = tonumber( new_args['j'] ) or -1
| |
| | |
| local len = ustring.len( s )
| |
| | |
| -- Convert negatives for range checking
| |
| if i < 0 then
| |
| i = len + i + 1
| |
| end
| |
| if j < 0 then
| |
| j = len + j + 1
| |
| end
| |
| | |
| if i > len or j > len or i < 1 or j < 1 then
| |
| return str._error( 'String subset index out of range' )
| |
| end
| |
| if j < i then
| |
| return str._error( 'String subset indices out of order' )
| |
| end
| |
| | |
| return ustring.sub( s, i, j )
| |
| end | | end |
|
| |
|
| -- 다른 모듈에서 require 되는 함수
| | function str.sublength( frame ) |
| function str._match( s, pattern, start, match_index, plain_flag, nomatch ) | | local i = tonumber( frame.args.i ) or 0 |
| if s == '' then
| | local len = tonumber( frame.args.len ) |
| return str._error( 'Target string is empty' )
| | return mw.ustring.sub( frame.args.s, i + 1, len and ( i + len ) ) |
| end
| |
| if pattern == '' then
| |
| return str._error( 'Pattern string is empty' )
| |
| end
| |
| start = tonumber(start) or 1
| |
| if math.abs(start) < 1 or math.abs(start) > ustring.len( s ) then
| |
| return str._error( 'Requested start is out of range' )
| |
| end
| |
| if match_index == 0 then
| |
| return str._error( 'Match index is out of range' )
| |
| end
| |
| if plain_flag then
| |
| pattern = str._escapePattern( pattern )
| |
| end
| |
| | |
| local result
| |
| if match_index == 1 then
| |
| -- Find first match is simple case
| |
| result = ustring.match( s, pattern, start )
| |
| else
| |
| if start > 1 then
| |
| s = ustring.sub( s, start )
| |
| end
| |
| | |
| local iterator = ustring.gmatch(s, pattern)
| |
| if match_index > 0 then
| |
| -- Forward search
| |
| for w in iterator do
| |
| match_index = match_index - 1
| |
| if match_index == 0 then
| |
| result = w
| |
| break
| |
| end
| |
| end
| |
| else
| |
| -- Reverse search
| |
| local result_table = {}
| |
| local count = 1
| |
| for w in iterator do
| |
| result_table[count] = w
| |
| count = count + 1
| |
| end
| |
| | |
| result = result_table[ count + match_index ]
| |
| end
| |
| end
| |
| | |
| if result == nil then
| |
| if nomatch == nil then
| |
| return str._error( 'Match not found' )
| |
| else
| |
| return nomatch
| |
| end
| |
| else
| |
| return result
| |
| end
| |
| end | | end |
|
| |
|
| -- string.match
| |
| function str.match( frame ) | | function str.match( frame ) |
| local args = getArgs(frame)
| | return mw.ustring.match( frame.args.s, frame.args.pattern, tonumber( frame.args.i ) ) |
| local new_args = str._getParameters( args, {'s', 'pattern', 'start', 'match', 'plain', 'nomatch'} )
| |
| local s = new_args['s'] or ''
| |
| local start = tonumber( new_args['start'] ) or 1
| |
| local plain_flag = str._getBoolean( new_args['plain'] or false )
| |
| local pattern = new_args['pattern'] or ''
| |
| local match_index = math.floor( tonumber(new_args['match']) or 1 )
| |
| local nomatch = new_args['nomatch']
| |
| | |
| return str._match( s, pattern, start, match_index, plain_flag, nomatch )
| |
| end
| |
| | |
| --
| |
| function str.pos( frame )
| |
| local args = getArgs(frame)
| |
| local new_args = str._getParameters( args, {'target', 'pos'} )
| |
| local target_str = new_args['target'] or ''
| |
| local pos = tonumber( new_args['pos'] ) or 0
| |
| | |
| if pos == 0 or math.abs(pos) > ustring.len( target_str ) then
| |
| return str._error( 'String index out of range' )
| |
| end
| |
| | |
| return ustring.sub( target_str, pos, pos )
| |
| end
| |
| | |
| -- string.find
| |
| function str.find( frame )
| |
| local args = getArgs(frame)
| |
| local new_args = str._getParameters( args, {'source', 'target', 'start', 'plain' } )
| |
| local source_str = new_args['source'] or ''
| |
| local pattern = new_args['target'] or ''
| |
| local start_pos = tonumber(new_args['start']) or 1
| |
| local plain = new_args['plain'] or false
| |
| | |
| if source_str == '' or pattern == '' then
| |
| return 0
| |
| end
| |
| | |
| plain = str._getBoolean( plain )
| |
| | |
| local start = ustring.find( source_str, pattern, start_pos, plain )
| |
|
| |
| if start == nil then
| |
| start = 0
| |
| end
| |
| | |
| return start
| |
| end | | end |
|
| |
|
| function str.find_( str1, str2 , str3, str4)
| | --[====[ |
| local source_str = str1 or ''
| | str_find |
| local pattern_str = str2 or ''
| |
| local start_ = str3 or 1
| |
| local plain_ = str4 or false
| |
|
| |
|
| if source_str == '' or pattern_str == '' then
| | This function duplicates the behavior of {{str_find}}, including all of its quirks. |
| return 0
| | This is provided in order to support existing templates, but is NOT RECOMMENDED for |
| end
| | new code and templates. New code is recommended to use the "find" function instead. |
|
| |
|
| plain_ = str._getBoolean( plain_ )
| | Returns the first index in "source" that is a match to "target". Indexing is 1-based, |
| | and the function returns -1 if the "target" string is not present in "source". Both |
| | strings have any leading or trailing whitespace removed before searching. |
|
| |
|
| local start = ustring.find( source_str, pattern_str, start_, plain_ )
| | Important Note: If the "target" string is empty / missing, this function returns a |
|
| | value of "1", which is generally unexpected behavior, and must be accounted for |
| if start == nil then
| | separatetly. |
| start = 0
| | ]====] |
| end
| | function str.str_find( frame ) |
| | | local source_str = frame.args.source or ''; |
| return start
| | local target_str = frame.args.target or ''; |
| | if target_str == '' then |
| | return 1; |
| | end |
| | |
| | local start = mw.ustring.find( source_str, target_str, 1, true ) |
| | if start == nil then |
| | start = -1 |
| | end |
| | |
| | return start |
| end | | end |
|
| |
|
| function str.ifexist( frame )
| | --[====[ |
| local args = getArgs(frame)
| | find |
| local new_args = str._getParameters( args, {'source', 'target', 'return1', 'return2' } )
| |
| local source_str = new_args['source'] or ''
| |
| local pattern = new_args['target'] or ''
| |
| local return1 = new_args['return1'] or ''
| |
| local return2 = new_args['return2'] or ''
| |
|
| |
|
| if str.find_( source_str, pattern) == 0 then
| | This function allows one to search for a target string or pattern within another |
| return return2
| | string. |
| else
| |
| return return1
| |
| end
| |
| end
| |
|
| |
|
| function str.ifexist_( source_str, pattern, return1, return2 )
| | Parameters: |
| if str.find_( source_str, pattern) == 0 then
| | source: The string to search |
| return return2
| | target: The string or pattern to find within source |
| else
| | start: The index within the source string to start the search, defaults to 1 |
| return return1
| | plain: Boolean flag indicating that target should be understood as plain |
| end
| | text and not as a Lua style regular expression, defaults to true |
| end
| | |
| | This function returns the first index >= "start" where "target" can be found |
| | within "source". Indices are 1-based. If "target" is not found, then this |
| | function returns 0. If either "source" or "target" are missing / empty, this |
| | function also returns 0. |
|
| |
|
| -- string.gsub | | Both "source" and "target" will be trimmed so that any leading or trailing |
| function str.gsub( frame ) | | whitespace is removed prior to searching. This function should be safe for |
| local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } )
| | UTF-8 strings. |
| local source_str = new_args['source'] or ''
| | ]====] |
| local pattern = new_args['pattern'] or ''
| | function str.find( frame ) |
| local replace = new_args['replace'] or ''
| | local source_str = frame.args.source or ''; |
| local count = tonumber( new_args['count'] )
| | local pattern = frame.args.target or ''; |
| local plain = new_args['plain'] or true
| | local start_pos = tonumber(frame.args.start) or 1; |
| | local plain = frame.args.plain or true; |
| | |
| | if source_str == '' or pattern == '' then |
| | return 0; |
| | end |
| | |
| | if type( plain ) == 'string' then |
| | plain = plain:lower(); |
| | if plain == 'false' or plain == 'no' or plain == '0' then |
| | plain = false; |
| | else |
| | plain = true; |
| | end |
| | end |
|
| |
|
| if source_str == '' or pattern == '' then
| | local start = mw.ustring.find( source_str, pattern, start_pos, plain ) |
| return source_str
| | if start == nil then |
| end
| | start = 0 |
| plain = str._getBoolean( plain )
| | end |
| | | |
| if plain then
| | return start |
| pattern = str._escapePattern( pattern )
| |
| replace = ustring.gsub( replace, "%%", "%%%%" ) --Only need to escape replacement sequences.
| |
| end
| |
| | |
| local result
| |
| | |
| if count ~= nil then
| |
| if replace == '제거' or replace == nil then
| |
| result = ustring.gsub( source_str, pattern, '', count)
| |
| else
| |
| result = ustring.gsub( source_str, pattern, replace, count )
| |
| end
| |
| else
| |
| if replace == '제거' or replace == nil then
| |
| result = ustring.gsub( source_str, pattern, '')
| |
| else
| |
| result = ustring.gsub( source_str, pattern, replace )
| |
| end
| |
| end
| |
| return result
| |
| end
| |
| | |
| -- string.rep
| |
| function str.rep( frame )
| |
| local repetitions = tonumber( frame.args[2] )
| |
| if not repetitions then
| |
| return str._error( 'function rep expects a number as second parameter, received "' .. ( frame.args[2] or '' ) .. '"' )
| |
| end
| |
| return ustring.rep( frame.args[1] or '', repetitions )
| |
| end
| |
| | |
| -- string.upper
| |
| function str.upper( frame )
| |
| local new_args = str._getParameters( frame.args, { 's' } )
| |
| local s = new_args['s'] or ''
| |
| return ustring.upper( s )
| |
| end | | end |
|
| |
| -- string.lower
| |
| function str.lower( frame )
| |
| local new_args = str._getParameters( frame.args, { 's' } )
| |
| local s = new_args['s'] or ''
| |
| return ustring.lower( s )
| |
| end
| |
|
| |
| function str.reverse( frame )
| |
| local new_args = str._getParameters( frame.args, { 's' } )
| |
| local s = new_args['s'] or ''
| |
| local str = ""
| |
| for token in ustring.gmatch(s, ".") do
| |
| str = token..str
| |
| end
| |
| return str
| |
| end
| |
|
| |
| -- string.byte의 유니코드 호환 버전
| |
| function str.tounicode( frame )
| |
| local args = getArgs( frame )
| |
| local s = args[1] or -1
| |
| if s == -1 then
| |
| return '입력값이 없습니다.'
| |
| else
| |
| return 'U+0'..ustring.upper(string.format("%x", ustring.codepoint(s)))
| |
| end
| |
| end
| |
|
| |
| function str.tounicode_( char )
| |
| local s = char or -1
| |
| if s == -1 then
| |
| return 0
| |
| else
| |
| return 'U+0'..ustring.upper(string.format("%x", ustring.codepoint(s)))
| |
| end
| |
| end
| |
|
| |
| -- string.char
| |
| function str.char( frame )
| |
| local args = getArgs(frame)
| |
| local new_args = str._getParameters( args, { 'c' } )
| |
| local c = tonumber(new_args['c'])
| |
| return ustring.char( c )
| |
| end
| |
|
| |
| function str.escapePattern( frame )
| |
| local args = getArgs(frame)
| |
| local pattern_str = args[1]
| |
| if not pattern_str then
| |
| return str._error( 'No pattern string specified' )
| |
| end
| |
| local result = str._escapePattern( pattern_str )
| |
| return result
| |
| end
| |
|
| |
| function str.count(frame)
| |
| local args_ = getArgs(frame)
| |
| local args = str._getParameters(args_, {'source', 'pattern', 'plain'})
| |
| local source = args.source or ''
| |
| local pattern = args.pattern or ''
| |
| local plain = str._getBoolean(args.plain or true)
| |
| if plain then
| |
| pattern = str._escapePattern(pattern)
| |
| end
| |
| local _, count = ustring.gsub(source, pattern, '')
| |
| return count
| |
| end
| |
|
| |
| function str.count_(str, pattern)
| |
| local _, count = ustring.gsub(str, pattern, '')
| |
| return count
| |
| end
| |
|
| |
| --[[
| |
| endswith
| |
| This function determines whether a string ends with another string.
| |
| ]]
| |
| function str.endswith(frame)
| |
| local args_ = getArgs(frame)
| |
| local args = str._getParameters(args_, {'source', 'pattern'})
| |
| local source = args.source or ''
| |
| local pattern = args.pattern or ''
| |
| if pattern == '' then
| |
| -- All strings end with the empty string.
| |
| return "yes"
| |
| end
| |
| if ustring.sub(source, -ustring.len(pattern), -1) == pattern then
| |
| return "yes"
| |
| else
| |
| return ""
| |
| end
| |
| end
| |
|
| |
| function str.join(frame)
| |
| local args = getArgs(frame)
| |
| local table_ = {}
| |
| local sep = args[1]
| |
| local i, j = 2, 1
| |
| -- args,table
| |
|
| |
| while args[i] ~= nil do
| |
| if args[i] ~= '_' then
| |
| table_[j] = args[i]
| |
| i = i + 1
| |
| j = j + 1
| |
| else
| |
| i = i + 1
| |
| end
| |
| end
| |
| return table.concat(table_, sep)
| |
| end
| |
|
| |
| --[[
| |
| Helper function that populates the argument list given that user may need to use a mix of
| |
| named and unnamed 변수. This is relevant because named 변수 are not
| |
| identical to unnamed 변수 due to string trimming, and when dealing with strings
| |
| we sometimes want to either preserve or remove that whitespace depending on the application.
| |
| ]]
| |
| function str._getParameters( frame_args, arg_list )
| |
| local new_args = {}
| |
| local index = 1
| |
| local value
| |
|
| |
| for _, arg in ipairs( arg_list ) do
| |
| value = frame_args[arg]
| |
| if value == nil then
| |
| value = frame_args[index]
| |
| index = index + 1
| |
| end
| |
| new_args[arg] = value
| |
| end
| |
|
| |
| return new_args
| |
| end
| |
|
| |
| --[[
| |
| Helper function to handle error messages.
| |
| ]]
| |
| function str._error( error_str )
| |
| local frame = mw.getCurrentFrame()
| |
| local error_category = frame.args.error_category or 'String 모듈에 의해 보고된 오류'
| |
| local ignore_errors = frame.args.ignore_errors or false
| |
| local no_category = frame.args.no_category or false
| |
|
| |
| if str._getBoolean(ignore_errors) then
| |
| return ''
| |
| end
| |
|
| |
| local error_str = '<strong class="error">String Module Error: ' .. error_str .. '</strong>'
| |
| if error_category ~= '' and not str._getBoolean( no_category ) then
| |
| error_str = '[[Category:' .. error_category .. ']]' .. error_str
| |
| end
| |
|
| |
| return error_str
| |
| end
| |
|
| |
| --[[
| |
| Helper Function to interpret boolean strings
| |
| ]]
| |
| function str._getBoolean( boolean_str )
| |
| local boolean_value
| |
|
| |
| if type( boolean_str ) == 'string' then
| |
| boolean_str = boolean_str:lower()
| |
| if boolean_str == 'false' or boolean_str == 'no' or boolean_str == '0'
| |
| or boolean_str == '' then
| |
| boolean_value = false
| |
| else
| |
| boolean_value = true
| |
| end
| |
| elseif type( boolean_str ) == 'boolean' then
| |
| boolean_value = boolean_str
| |
| else
| |
| error( 'No boolean value found' )
| |
| end
| |
| return boolean_value
| |
| end
| |
|
| |
| --[[
| |
| Helper function that escapes all pattern characters so that they will be treated
| |
| as plain text.
| |
| ]]
| |
| function str._escapePattern( pattern_str )
| |
| return ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )
| |
| end
| |
|
| |
| return str | | return str |