최신판 |
당신의 편집 |
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'} )
| | end |
| 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
| | pos |
|
| |
|
| --
| | This function returns a single character from the target string at position pos. |
| 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
| | Usage: |
| return str._error( 'String index out of range' )
| | {{#invoke:String|pos|target_string|index_value}} |
| end
| | OR |
| | {{#invoke:String|pos|target=target_string|pos=index_value}} |
|
| |
|
| return ustring.sub( target_str, pos, pos )
| | Parameters |
| end
| | target: The string to search |
| | pos: The index for the character to return |
|
| |
|
| -- string.find
| | If invoked using named parameters, Mediawiki will automatically remove any leading or |
| function str.find( frame )
| | trailing whitespace from the target string. In some circumstances this is desirable, in |
| local args = getArgs(frame)
| | other cases one may want to preserve the whitespace. |
| 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
| | The first character has an index value of 1. |
| return 0
| |
| end
| |
|
| |
|
| plain = str._getBoolean( plain )
| | If one requests a negative value, this function will select a character by counting backwards |
| | from the end of the string. In other words pos = -1 is the same as asking for the last character. |
|
| |
|
| local start = ustring.find( source_str, pattern, start_pos, plain )
| | A requested value of zero, or a value greater than the length of the string returns an error. |
|
| | ]====] |
| if start == nil then
| | function str.pos( frame ) |
| start = 0
| | local new_args = str._getParameters( frame.args, {'target', 'pos'} ); |
| end
| | local target_str = new_args['target'] or ''; |
| | local pos = tonumber( new_args['pos'] ) or 0; |
|
| |
|
| return start
| | if pos == 0 or math.abs(pos) > mw.ustring.len( target_str ) then |
| | return '<strong class="error">String index out of range</strong>'; |
| | end |
| | |
| | return mw.ustring.sub( target_str, pos, pos ); |
| 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". |
|
| |
|
| 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 new_args = str._getParameters( frame.args, {'source', 'target'} ); |
| | local source_str = new_args['source'] or ''; |
| | local target_str = new_args['target'] or ''; |
|
| |
|
| return start
| | 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 )
| | Usage: |
| if str.find_( source_str, pattern) == 0 then
| | {{#invoke:String|find|source_str|target_string|start_index|plain_flag}} |
| return return2
| | OR |
| else
| | {{#invoke:String|find|source=source_str|target=target_str|start=start_index|plain=plain_flag}} |
| return return1
| |
| end
| |
| end
| |
|
| |
|
| -- string.gsub
| | Parameters |
| function str.gsub( frame )
| | source: The string to search |
| local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } )
| | target: The string or pattern to find within source |
| local source_str = new_args['source'] or ''
| | start: The index within the source string to start the search, defaults to 1 |
| local pattern = new_args['pattern'] or ''
| | plain: Boolean flag indicating that target should be understood as plain |
| local replace = new_args['replace'] or ''
| | text and not as a Lua style regular expression, defaults to true |
| local count = tonumber( new_args['count'] )
| |
| local plain = new_args['plain'] or true
| |
|
| |
|
| if source_str == '' or pattern == '' then
| | If invoked using named parameters, Mediawiki will automatically remove any leading or |
| return source_str
| | trailing whitespace from the parameter. In some circumstances this is desirable, in |
| end
| | other cases one may want to preserve the whitespace. |
| plain = str._getBoolean( plain )
| |
|
| |
|
| if plain then
| | This function returns the first index >= "start" where "target" can be found |
| pattern = str._escapePattern( pattern )
| | within "source". Indices are 1-based. If "target" is not found, then this |
| replace = ustring.gsub( replace, "%%", "%%%%" ) --Only need to escape replacement sequences.
| | function returns 0. If either "source" or "target" are missing / empty, this |
| end
| | function also returns 0. |
|
| |
|
| local result
| | This function should be safe for UTF-8 strings. |
| | ]====] |
| | function str.find( frame ) |
| | local new_args = str._getParameters( frame.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 true; |
| | |
| | if source_str == '' or pattern == '' then |
| | return 0; |
| | end |
| | |
| | plain = str._getBoolean( plain ); |
|
| |
|
| if count ~= nil then
| | local start = mw.ustring.find( source_str, pattern, start_pos, plain ) |
| if replace == '제거' or replace == nil then
| | if start == nil then |
| result = ustring.gsub( source_str, pattern, '', count)
| | start = 0 |
| else
| | end |
| result = ustring.gsub( source_str, pattern, replace, count )
| | |
| end
| | return start |
| 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 | | end |
|
| |
|
| -- string.rep | | --[====[ |
| function str.rep( frame )
| | replace |
| 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
| | This function allows one to replace a target string or pattern within another |
| function str.upper( frame )
| | string. |
| local new_args = str._getParameters( frame.args, { 's' } )
| |
| local s = new_args['s'] or ''
| |
| return ustring.upper( s )
| |
| end
| |
|
| |
|
| -- string.lower
| | Usage: |
| function str.lower( frame )
| | {{#invoke:String|replace|source_str|pattern_string|replace_string|replacement_count|plain_flag}} |
| local new_args = str._getParameters( frame.args, { 's' } )
| | OR |
| local s = new_args['s'] or ''
| | {{#invoke:String|replace|source=source_string|pattern=pattern_string|replace=replace_string| |
| return ustring.lower( s )
| | count=replacement_count|plain=plain_flag}} |
| end
| |
|
| |
|
| function str.reverse( frame ) | | Parameters |
| local new_args = str._getParameters( frame.args, { 's' } )
| | source: The string to search |
| local s = new_args['s'] or ''
| | pattern: The string or pattern to find within source |
| local str = ""
| | replace: The replacement text |
| for token in ustring.gmatch(s, ".") do
| | count: The number of occurences to replace, defaults to all. |
| str = token..str
| | plain: Boolean flag indicating that pattern should be understood as plain |
| end
| | text and not as a Lua style regular expression, defaults to true |
| return str
| | ]====] |
| end
| | function str.replace( frame ) |
| | | local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } ); |
| -- string.byte의 유니코드 호환 버전
| | local source_str = new_args['source'] or ''; |
| function str.tounicode( frame )
| | local pattern = new_args['pattern'] or ''; |
| local args = getArgs( frame )
| | local replace = new_args['replace'] or ''; |
| local s = args[1] or -1
| | local count = tonumber( new_args['count'] ); |
| if s == -1 then
| | local plain = new_args['plain'] or true; |
| return '입력값이 없습니다.'
| | |
| else
| | if source_str == '' or pattern == '' then |
| return 'U+0'..ustring.upper(string.format("%x", ustring.codepoint(s)))
| | return source_str; |
| end
| | end |
| end
| | plain = str._getBoolean( plain ); |
|
| |
|
| function str.tounicode_( char )
| | if plain then |
| local s = char or -1
| | pattern = str._escapePattern( pattern ); |
| if s == -1 then
| | replace = str._escapePattern( replace ); |
| return 0
| | end |
| else
| | |
| return 'U+0'..ustring.upper(string.format("%x", ustring.codepoint(s)))
| | local result; |
| end
| |
| end
| |
|
| |
|
| -- string.char
| | if count ~= nil then |
| function str.char( frame )
| | result = mw.ustring.gsub( source_str, pattern, replace, count ); |
| local args = getArgs(frame)
| | else |
| local new_args = str._getParameters( args, { 'c' } )
| | result = mw.ustring.gsub( source_str, pattern, replace ); |
| local c = tonumber(new_args['c'])
| | end |
| 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)
| | return result; |
| 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 | | 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 | | 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 | | named and unnamed parameters. This is relevant because named parameters are not |
| identical to unnamed 변수 due to string trimming, and when dealing with strings | | identical to unnamed parameters due to string trimming, and when dealing with strings |
| we sometimes want to either preserve or remove that whitespace depending on the application. | | we sometimes want to either preserve or remove that whitespace depending on the application. |
| ]] | | ]====] |
| function str._getParameters( frame_args, arg_list ) | | function str._getParameters( frame_args, arg_list ) |
| local new_args = {}
| | local new_args = {}; |
| local index = 1
| | local index = 1; |
| local value
| | local value; |
| | | |
| for _, arg in ipairs( arg_list ) do
| | for i,arg in ipairs( arg_list ) do |
| value = frame_args[arg]
| | value = frame_args[arg] |
| if value == nil then
| | if value == nil then |
| value = frame_args[index]
| | value = frame_args[index]; |
| index = index + 1
| | index = index + 1; |
| end
| | end |
| new_args[arg] = value
| | new_args[arg] = value; |
| end
| | end |
| | | |
| return new_args
| | return new_args; |
| end | | 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 | | Helper Function to interpret boolean strings |
| ]] | | ]====] |
| function str._getBoolean( boolean_str ) | | function str._getBoolean( boolean_str ) |
| local boolean_value
| | local boolean_value; |
| | | |
| if type( boolean_str ) == 'string' then
| | if type( boolean_str ) == 'string' then |
| boolean_str = boolean_str:lower()
| | boolean_str = boolean_str:lower(); |
| if boolean_str == 'false' or boolean_str == 'no' or boolean_str == '0'
| | if boolean_str == 'false' or boolean_str == 'no' or boolean_str == '0' then |
| or boolean_str == '' then
| | boolean_value = false; |
| boolean_value = false
| | else |
| else
| | boolean_value = true; |
| boolean_value = true
| | end |
| end
| | elseif type( boolean_str ) == 'boolean' then |
| elseif type( boolean_str ) == 'boolean' then
| | boolean_value = boolean_str; |
| boolean_value = boolean_str
| | else |
| else
| | error( 'No boolean value found' ); |
| error( 'No boolean value found' )
| | end |
| end
| | return boolean_value |
| return boolean_value
| |
| end | | end |
|
| |
|
| --[[ | | --[====[ |
| Helper function that escapes all pattern characters so that they will be treated | | Helper function that escapes all pattern characters so that they will be treated |
| as plain text. | | as plain text. |
| ]] | | ]====] |
| function str._escapePattern( pattern_str ) | | function str._escapePattern( pattern_str ) |
| return ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )
| | return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" ); |
| end | | end |
|
| |
|
| return str | | return str |