|
|
(No se muestra una edición intermedia de otro usuario) |
Línea 1: |
Línea 1: |
| --[[ | | --[[ |
| | | Este módulo está destinado a proporcionar acceso a las funciones de cadena (string) básicas. |
| This module is intended to provide access to basic string functions.
| |
| | |
| Most of the functions provided here can be invoked with named parameters,
| |
| unnamed parameters, or a mixture. If named parameters are used, Mediawiki will
| |
| automatically remove any leading or trailing whitespace from the parameter.
| |
| Depending on the intended use, it may be advantageous to either preserve or
| |
| remove such whitespace.
| |
| | |
| Global options
| |
| ignore_errors: If set to 'true' or 1, any error condition will result in
| |
| an empty string being returned rather than an error message.
| |
| | |
| error_category: If an error occurs, specifies the name of a category to
| |
| include with the error message. The default category is
| |
| [Category:Errors reported by Module String].
| |
| | |
| no_category: If set to 'true' or 1, no category will be added if an error
| |
| is generated.
| |
| | |
| Unit tests for this module are available at Module:String/tests.
| |
| ]] | | ]] |
|
| |
|
Línea 28: |
Línea 8: |
| len | | len |
|
| |
|
| This function returns the length of the target string.
| | Parametros |
| | | s: La cadena a encontrar su longitud |
| Usage:
| |
| {{#invoke:String|len|target_string|}}
| |
| OR
| |
| {{#invoke:String|len|s=target_string}}
| |
|
| |
|
| Parameters
| |
| s: The string whose length to report
| |
|
| |
| If invoked using named parameters, Mediawiki will automatically remove any leading or
| |
| trailing whitespace from the target string.
| |
| ]] | | ]] |
| function str.len( frame ) | | function str.len( frame ) |
| local new_args = str._getParameters( frame.args, {'s'} )
| | local new_args = str._getParameters( frame.args, {'s'} ); |
| local s = new_args['s'] or ''
| | local s = new_args['s'] or ''; |
| return mw.ustring.len( s )
| | return mw.ustring.len( s ) |
| end | | end |
|
| |
|
Línea 50: |
Línea 21: |
| sub | | sub |
|
| |
|
| This function returns a substring of the target string at specified indices.
| | Parametros |
| | | s: La cadena donde extraer la subcadena |
| Usage:
| | i: La cadena donde extraer la subcadena. |
| {{#invoke:String|sub|target_string|start_index|end_index}}
| | j: Índice final de la subcadena, por defecto la longitud total, hasta el último carácter. |
| OR
| | |
| {{#invoke:String|sub|s=target_string|i=start_index|j=end_index}}
| |
| | |
| Parameters
| |
| s: The string to return a subset of | |
| i: The first index of the substring to return, defaults to 1. | |
| j: The last index of the string to return, defaults to the last character. | |
| | |
| The first character of the string is assigned an index of 1. If either i or j
| |
| is a negative value, it is interpreted the same as selecting a character by
| |
| counting from the end of the string. Hence, a value of -1 is the same as
| |
| selecting the last character of the string.
| |
| | |
| If the requested indices are out of range for the given string, an error is
| |
| reported.
| |
| ]] | | ]] |
| function str.sub( frame ) | | function str.sub( frame ) |
| local new_args = str._getParameters( frame.args, { 's', 'i', 'j' } )
| | local new_args = str._getParameters( frame.args, { 's', 'i', 'j' } ); |
| local s = new_args['s'] or ''
| | local s = new_args['s'] or ''; |
| local i = tonumber( new_args['i'] ) or 1
| | local i = tonumber( new_args['i'] ) or 1; |
| local j = tonumber( new_args['j'] ) or -1
| | local j = tonumber( new_args['j'] ) or -1; |
| | | |
| local len = mw.ustring.len( s )
| | local len = mw.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
| | -- Convertir negativos para la comprobación de rango |
| return str._error( 'String subset index out of range' )
| | if i < 0 then |
| end
| | i = len + i + 1; |
| if j < i then
| | end |
| return str._error( 'String subset indices out of order' )
| | if j < 0 then |
| end
| | j = len + j + 1; |
| | | end |
| return mw.ustring.sub( s, i, j )
| | |
| end
| | if i > len or j > len or i < 1 or j < 1 then |
| | | return str._error( 'Índice fuera del rango de la cadena' ); |
| --[[
| | end |
| This function implements that features of {{str sub old}} and is kept in order
| | if j < i then |
| to maintain these older templates.
| | return str._error( 'Índices de la cadena no ordenados' ); |
| ]]
| | end |
| function str.sublength( frame )
| | |
| local i = tonumber( frame.args.i ) or 0
| | return mw.ustring.sub( s, i, j ) |
| local len = tonumber( frame.args.len )
| |
| return mw.ustring.sub( frame.args.s, i + 1, len and ( i + len ) )
| |
| end | |
| | |
| --[[
| |
| _match
| |
| | |
| This function returns a substring from the source string that matches a
| |
| specified pattern. It is exported for use in other modules
| |
| | |
| Usage:
| |
| strmatch = require("Module:String")._match
| |
| sresult = strmatch( s, pattern, start, match, plain, nomatch )
| |
| | |
| Parameters
| |
| s: The string to search | |
| pattern: The pattern or string to find within the string | |
| start: The index within the source string to start the search. The first
| |
| character of the string has index 1. Defaults to 1.
| |
| match: In some cases it may be possible to make multiple matches on a single
| |
| string. This specifies which match to return, where the first match is
| |
| match= 1. If a negative number is specified then a match is returned
| |
| counting from the last match. Hence match = -1 is the same as requesting
| |
| the last match. Defaults to 1.
| |
| plain: A flag indicating that the pattern should be understood as plain
| |
| text. Defaults to false. | |
| nomatch: If no match is found, output the "nomatch" value rather than an error.
| |
| | |
| For information on constructing Lua patterns, a form of [regular expression], see:
| |
| | |
| * http://www.lua.org/manual/5.1/manual.html#5.4.1
| |
| * http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns
| |
| * http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns
| |
| | |
| ]]
| |
| -- This sub-routine is exported for use in other modules
| |
| function str._match( s, pattern, start, match_index, plain_flag, nomatch )
| |
| if s == '' then
| |
| return str._error( 'Target string is empty' )
| |
| 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) > mw.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 = mw.ustring.match( s, pattern, start )
| |
| else
| |
| if start > 1 then
| |
| s = mw.ustring.sub( s, start )
| |
| end
| |
| | |
| local iterator = mw.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 |
|
| |
|
Línea 202: |
Línea 56: |
| match | | match |
|
| |
|
| This function returns a substring from the source string that matches a
| | Parametros |
| specified pattern.
| | s: cadena donde se hace la búsqueda |
| | | pattern: patrón o cadena a buscar. |
| Usage:
| | start: índice de la cadena dónde empezar a buscar, por defecto 1, el primer carácter. |
| {{#invoke:String|match|source_string|pattern_string|start_index|match_number|plain_flag|nomatch_output}}
| | match: si se encuentran múltiples coincidencias, especifica cuál de ellas devolver. Por defecto es 1, l |
| OR
| | la primera coincidencia encontrada. Un número negativo cuenta desde el final, por lo tanto |
| {{#invoke:String|match|s=source_string|pattern=pattern_string|start=start_index
| | match = -1 es la última coincidencia. |
| |match=match_number|plain=plain_flag|nomatch=nomatch_output}}
| | plain: indica si el patrón debe interpretarse como texto limpio, por defecto 'false'. nomatch: en caso de |
| | | no encontrar ninguna coincidencia, devuelve el valor de "nomatch" en lugar de un error. |
| Parameters
| | Si el número match o el índice start están fuera del rango de la cadena, entonces la función genera un error. |
| s: The string to search
| | También genera un error si no encuentra ninguna coincidencia. |
| pattern: The pattern or string to find within the string
| | Con el parámetro global ignore_errors = true se suprime el |
| start: The index within the source string to start the search. The first
| | error y devuelve una cadena vacía. |
| character of the string has index 1. Defaults to 1.
| |
| match: In some cases it may be possible to make multiple matches on a single
| |
| string. This specifies which match to return, where the first match is
| |
| match= 1. If a negative number is specified then a match is returned
| |
| counting from the last match. Hence match = -1 is the same as requesting
| |
| the last match. Defaults to 1.
| |
| plain: A flag indicating that the pattern should be understood as plain
| |
| text. Defaults to false.
| |
| nomatch: If no match is found, output the "nomatch" value rather than an error.
| |
| | |
| If invoked using named parameters, Mediawiki will automatically remove any leading or
| |
| trailing whitespace from each string. In some circumstances this is desirable, in
| |
| other cases one may want to preserve the whitespace.
| |
| | |
| If the match_number or start_index are out of range for the string being queried, then
| |
| this function generates an error. An error is also generated if no match is found.
| |
| If one adds the parameter ignore_errors=true, then the error will be suppressed and
| |
| an empty string will be returned on any failure.
| |
| | |
| For information on constructing Lua patterns, a form of [regular expression], see:
| |
| | |
| * http://www.lua.org/manual/5.1/manual.html#5.4.1
| |
| * http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns
| |
| * http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns
| |
| | |
| ]] | | ]] |
| -- This is the entry point for #invoke:String|match
| |
| function str.match( frame ) | | function str.match( frame ) |
| local new_args = str._getParameters( frame.args, {'s', 'pattern', 'start', 'match', 'plain', 'nomatch'} )
| | local new_args = str._getParameters( frame.args, {'s', 'pattern', 'start', 'match', 'plain', 'nomatch'} ); |
| local s = new_args['s'] or ''
| | local s = new_args['s'] or ''; |
| local start = tonumber( new_args['start'] ) or 1
| | local start = tonumber( new_args['start'] ) or 1; |
| local plain_flag = str._getBoolean( new_args['plain'] or false )
| | local plain_flag = str._getBoolean( new_args['plain'] or false ); |
| local pattern = new_args['pattern'] or ''
| | local pattern = new_args['pattern'] or ''; |
| local match_index = math.floor( tonumber(new_args['match']) or 1 )
| | local match_index = math.floor( tonumber(new_args['match']) or 1 ); |
| local nomatch = new_args['nomatch']
| | local nomatch = new_args['nomatch']; |
| | | |
| return str._match( s, pattern, start, match_index, plain_flag, nomatch )
| | if s == '' then |
| | return str._error( 'La cadena donde buscar está vacía' ); |
| | end |
| | if pattern == '' then |
| | return str._error( 'La cadena de búsqueda está vacía ' ); |
| | end |
| | if math.abs(start) < 1 or math.abs(start) > mw.ustring.len( s ) then |
| | return str._error( 'Índice d\'inicio fuera del rango de la cadena ' ); |
| | end |
| | if match_index == 0 then |
| | return str._error( 'Número de coincidencias fuera de rango' ); |
| | end |
| | if plain_flag then |
| | pattern = str._escapePattern( pattern ); |
| | end |
| | |
| | local result |
| | if match_index == 1 then |
| | -- Encontrar la primera coincidencia es un caso sencillo. |
| | result = mw.ustring.match( s, pattern, start ) |
| | else |
| | if start > 1 then |
| | s = mw.ustring.sub( s, start ); |
| | end |
| | |
| | local iterator = mw.ustring.gmatch(s, pattern); |
| | if match_index > 0 then |
| | -- Búsqueda hacia adelante |
| | for w in iterator do |
| | match_index = match_index - 1; |
| | if match_index == 0 then |
| | result = w; |
| | break; |
| | end |
| | end |
| | else |
| | -- Invierte búsqueda |
| | 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( 'Ninguna coincidencia encontrada' ); |
| | else |
| | return nomatch; |
| | end |
| | else |
| | return result; |
| | end |
| end | | end |
|
| |
|
Línea 257: |
Línea 141: |
| pos | | pos |
|
| |
|
| This function returns a single character from the target string at position pos.
| | Parámetros |
| | | target: Cadena donde buscar. |
| Usage:
| | pos: Índice del carácter a devolver. |
| {{#invoke:String|pos|target_string|index_value}}
| |
| OR
| |
| {{#invoke:String|pos|target=target_string|pos=index_value}}
| |
| | |
| Parameters
| |
| target: The string to search
| |
| pos: The index for the character to return
| |
| | |
| If invoked using named parameters, Mediawiki will automatically remove any leading or
| |
| trailing whitespace from the target string. In some circumstances this is desirable, in
| |
| other cases one may want to preserve the whitespace.
| |
| | |
| The first character has an index value of 1.
| |
| | |
| 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.
| |
| | |
| A requested value of zero, or a value greater than the length of the string returns an error.
| |
| ]] | | ]] |
| function str.pos( frame ) | | function str.pos( frame ) |
| local new_args = str._getParameters( frame.args, {'target', 'pos'} )
| | local new_args = str._getParameters( frame.args, {'target', 'pos'} ); |
| local target_str = new_args['target'] or ''
| | local target_str = new_args['target'] or ''; |
| local pos = tonumber( new_args['pos'] ) or 0
| | local pos = tonumber( new_args['pos'] ) or 0; |
| | |
| if pos == 0 or math.abs(pos) > mw.ustring.len( target_str ) then
| |
| return str._error( 'String index out of range' )
| |
| end
| |
|
| |
|
| return mw.ustring.sub( target_str, pos, pos )
| | if pos == 0 or math.abs(pos) > mw.ustring.len( target_str ) then |
| end
| | return str._error( 'Índice fuera del rango de la cadena' ); |
| | | end |
| --[[
| | |
| str_find
| | return mw.ustring.sub( target_str, pos, pos ); |
| | |
| This function duplicates the behavior of {{str_find}}, including all of its quirks.
| |
| This is provided in order to support existing templates, but is NOT RECOMMENDED for
| |
| new code and templates. New code is recommended to use the "find" function instead.
| |
| | |
| 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".
| |
| | |
| 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
| |
| separatetly.
| |
| ]]
| |
| 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 ''
| |
| | |
| 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 |
|
| |
|
Línea 325: |
Línea 160: |
| find | | find |
|
| |
|
| This function allows one to search for a target string or pattern within another
| | Parametros |
| string.
| | source: Cadena donde buscar. |
| | | target: Cadena a buscar o patrón de búsqueda. |
| Usage:
| | start: Índice de la cadena fuente donde empezar a buscar, por defecto 1, el primer carácter. |
| {{#invoke:String|find|source_str|target_string|start_index|plain_flag}}
| | plain: Indica si la búsqueda debe interpretarse como texto limpio, de lo contrario como patrón Lua. |
| OR
| | Por defecto es 'true'. |
| {{#invoke:String|find|source=source_str|target=target_str|start=start_index|plain=plain_flag}}
| |
| | |
| Parameters
| |
| source: The string to search | |
| target: The string or pattern to find within source | |
| start: The index within the source string to start the search, defaults to 1 | |
| plain: Boolean flag indicating that target should be understood as plain | |
| text and not as a Lua style regular expression, defaults to true | |
| | |
| If invoked using named parameters, Mediawiki will automatically remove any leading or
| |
| trailing whitespace from the parameter. In some circumstances this is desirable, in
| |
| other cases one may want to preserve the whitespace.
| |
| | |
| 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.
| |
| | |
| This function should be safe for UTF-8 strings.
| |
| ]] | | ]] |
| function str.find( frame ) | | function str.find( frame ) |
| local new_args = str._getParameters( frame.args, {'source', 'target', 'start', 'plain' } )
| | local new_args = str._getParameters( frame.args, {'source', 'target', 'start', 'plain' } ); |
| local source_str = new_args['source'] or ''
| | local source_str = new_args['source'] or ''; |
| local pattern = new_args['target'] or ''
| | local pattern = new_args['target'] or ''; |
| local start_pos = tonumber(new_args['start']) or 1
| | local start_pos = tonumber(new_args['start']) or 1; |
| local plain = new_args['plain'] or true
| | local plain = new_args['plain'] or true; |
| | | |
| if source_str == '' or pattern == '' then
| | if source_str == '' or pattern == '' then |
| return 0
| | return 0; |
| end
| | end |
| | | |
| plain = str._getBoolean( plain )
| | plain = str._getBoolean( plain ); |
| | |
| local start = mw.ustring.find( source_str, pattern, start_pos, plain )
| |
| if start == nil then
| |
| start = 0
| |
| end
| |
|
| |
|
| return start
| | local start = mw.ustring.find( source_str, pattern, start_pos, plain ) |
| | if start == nil then |
| | start = 0 |
| | end |
| | |
| | return start |
| end | | end |
|
| |
|
Línea 375: |
Línea 191: |
| replace | | replace |
|
| |
|
| This function allows one to replace a target string or pattern within another
| | Parámetros |
| string.
| | source: Cadena donde buscar |
| | | pattern: Cadena de búsqueda o patrón a buscar |
| Usage:
| | replace: Texto de reemplazo |
| {{#invoke:String|replace|source_str|pattern_string|replace_string|replacement_count|plain_flag}}
| | count: Número de ocurrencias a reemplazar, por defecto todas. |
| OR
| | plain: Indica si la búsqueda debe interpretarse como texto limpio, de lo contrario como patrón Lua. Por |
| {{#invoke:String|replace|source=source_string|pattern=pattern_string|replace=replace_string|
| | defecto es 'true' |
| count=replacement_count|plain=plain_flag}}
| |
| | |
| Parameters
| |
| source: The string to search | |
| pattern: The string or pattern to find within source | |
| replace: The replacement text | |
| count: The number of occurences to replace, defaults to all. | |
| plain: Boolean flag indicating that pattern should be understood as plain | |
| text and not as a Lua style regular expression, defaults to true | |
| ]] | | ]] |
| function str.replace( frame ) | | function str.replace( frame ) |
| local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } )
| | local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } ); |
| local source_str = new_args['source'] or ''
| | local source_str = new_args['source'] or ''; |
| local pattern = new_args['pattern'] or ''
| | local pattern = new_args['pattern'] or ''; |
| local replace = new_args['replace'] or ''
| | local replace = new_args['replace'] or ''; |
| local count = tonumber( new_args['count'] )
| | local count = tonumber( new_args['count'] ); |
| local plain = new_args['plain'] or true
| | local plain = new_args['plain'] or true; |
| | | |
| if source_str == '' or pattern == '' then
| | if source_str == '' or pattern == '' then |
| return source_str
| | return source_str; |
| end
| | end |
| plain = str._getBoolean( plain )
| | plain = str._getBoolean( plain ); |
| | |
| if plain then
| |
| pattern = str._escapePattern( pattern )
| |
| replace = mw.ustring.gsub( replace, "%%", "%%%%" ) --Only need to escape replacement sequences.
| |
| end
| |
|
| |
|
| local result
| | if plain then |
| | pattern = str._escapePattern( pattern ); |
| | replace = mw.ustring.gsub( replace, "%%", "%%%%" ); --Sólo es necesario secuencias de escape. |
| | end |
| | |
| | local result; |
|
| |
|
| if count ~= nil then
| | if count ~= nil then |
| result = mw.ustring.gsub( source_str, pattern, replace, count )
| | result = mw.ustring.gsub( source_str, pattern, replace, count ); |
| else
| | else |
| result = mw.ustring.gsub( source_str, pattern, replace )
| | result = mw.ustring.gsub( source_str, pattern, replace ); |
| end
| | end |
|
| |
|
| return result
| | return result; |
| end | | end |
|
| |
|
| --[[ | | --[[ |
| simple function to pipe string.rep to templates.
| | count |
| ]]
| |
| 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 string.rep( frame.args[1] or '', repetitions )
| |
| end
| |
| | |
| --[[
| |
| escapePattern
| |
| | |
| This function escapes special characters from a Lua string pattern. See [1]
| |
| for details on how patterns work.
| |
| | |
| [1] https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns
| |
| | |
| Usage:
| |
| {{#invoke:String|escapePattern|pattern_string}}
| |
| | |
| Parameters
| |
| pattern_string: The pattern string to escape.
| |
| ]]
| |
| function str.escapePattern( frame )
| |
| local pattern_str = frame.args[1]
| |
| if not pattern_str then
| |
| return str._error( 'No pattern string specified' )
| |
| end
| |
| local result = str._escapePattern( pattern_str )
| |
| return result
| |
| end
| |
|
| |
|
| --[[
| | Esta funsción cuenta el número de existencias de un carácter o una cadena (no supuerpuestos) dentro de otra cadena. |
| count
| |
| This function counts the number of occurrences of one string in another.
| |
| ]] | | ]] |
| function str.count(frame) | | function str.count(frame) |
Línea 471: |
Línea 245: |
| end | | end |
|
| |
|
| --[[
| | function str.mayuscula(frame) -- Convierte en mayúsculas la primera letra que aparece en la edición de una cadena |
| endswith
| | local s = frame.args[1] or ''; |
| This function determines whether a string ends with another string.
| | if s ~= '' then |
| ]]
| | local cambio = {}; |
| function str.endswith(frame) | | local modo = {}; |
| local args = str._getParameters(frame.args, {'source', 'pattern'})
| | if string.find(s, '|') ~= nil then -- Enlaces con etiqueta |
| local source = args.source or ''
| | modo = string.upper(string.match(s,'(|%a)')); |
| local pattern = args.pattern or ''
| | cambio = string.gsub(s,'|%a', modo,1); |
| if pattern == '' then
| | elseif string.find(s, '[[]') ~= nil then -- Enlaces sin etiqueta |
| -- All strings end with the empty string.
| | modo = string.upper(string.match(s,'^(..%a)')); |
| return "yes"
| | cambio = string.gsub(s,'^..%a', modo,1); |
| end
| | elseif string.match(s,'^%a') ~= nil then -- Sin enlace |
| if mw.ustring.sub(source, -mw.ustring.len(pattern), -1) == pattern then
| | modo = string.upper(string.match(s,'^(%a)')); |
| return "yes"
| | cambio = string.gsub(s,'^%a', modo, 1); |
| else
| | else |
| return ""
| | cambio = s; |
| end
| | end |
| end
| | return cambio; |
| | | end |
| --[[ | |
| join
| |
| | |
| Join all non empty arguments together; the first argument is the separator.
| |
| Usage:
| |
| {{#invoke:String|join|sep|one|two|three}}
| |
| ]]
| |
| function str.join(frame)
| |
| local args = {}
| |
| local sep
| |
| for _, v in ipairs( frame.args ) do
| |
| if sep then
| |
| if v ~= '' then
| |
| table.insert(args, v)
| |
| end
| |
| else
| |
| sep = v
| |
| end
| |
| end
| |
| return table.concat( args, sep or '' )
| |
| end | | end |
|
| |
|
| --[[ | | --[[ |
| Helper function that populates the argument list given that user may need to use a mix of
| | Función de ayuda que rellena la lista de argumentos, para que el usuario pueda utilizar una combinación de |
| named and unnamed parameters. This is relevant because named parameters are not
| | parámetros con nombre y sin nombre. Esto es importante porque los parámetros con nombre no funcionan igual |
| identical to unnamed parameters due to string trimming, and when dealing with strings
| | que los parámetros sin nombre cuando se encadenan recortes, y cuando se trata de cadenas |
| we sometimes want to either preserve or remove that whitespace depending on the application.
| | a veces se debe conservar o quitar espacios en blanco dependiendo de la aplicación. |
| ]] | | ]] |
| 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.
| | Función de ayuda para controlar los mensajes de error. |
| ]] | | ]] |
| function str._error( error_str ) | | function str._error( error_str ) |
| local frame = mw.getCurrentFrame()
| | local frame = mw.getCurrentFrame(); |
| local error_category = frame.args.error_category or 'Errors reported by Module String'
| | local error_category = frame.args.error_category or 'Errores detectados por el módulo String'; |
| local ignore_errors = frame.args.ignore_errors or false
| | local ignore_errors = frame.args.ignore_errors or false; |
| local no_category = frame.args.no_category or false
| | local no_category = frame.args.no_category or false; |
| | | |
| if str._getBoolean(ignore_errors) then
| | if str._getBoolean(ignore_errors) then |
| return ''
| | return ''; |
| end
| | end |
| | | |
| local error_str = '<strong class="error">String Module Error: ' .. error_str .. '</strong>'
| | local error_str = '<strong class="error">Error del módulo String: ' .. error_str .. '</strong>'; |
| if error_category ~= '' and not str._getBoolean( no_category ) then
| | if error_category ~= '' and not str._getBoolean( no_category ) then |
| error_str = '[[Category:' .. error_category .. ']]' .. error_str
| | error_str = '[[Categoría:Wikipedia:' .. error_category .. ']]' .. error_str; |
| end
| | end |
| | | |
| return error_str
| | return error_str; |
| end | | end |
|
| |
|
| --[[ | | --[[ |
| Helper Function to interpret boolean strings
| | Función de ayuda para interpretar cadenas booleanas. |
| ]] | | ]] |
| 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' |
| or boolean_str == '' 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( 'Ningún valor booleano encontrado' ); |
| end
| | end |
| return boolean_value
| | return boolean_value |
| end | | end |
|
| |
|
| --[[ | | --[[ |
| Helper function that escapes all pattern characters so that they will be treated
| | Función de ayuda que escapa a todos los caracteres de patrón para que puedan ser tratados |
| as plain text.
| | como texto sin formato. |
| ]] | | ]] |
| function str._escapePattern( pattern_str ) | | function str._escapePattern( pattern_str ) |
| return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )
| | return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" ); |
| end | | end |
|
| |
|
| return str | | return str |