Jump to content

Wikipedia The Free Encyclopedia

Module:String/sandbox

From Wikipedia, the free encyclopedia

< Module:String

This is the module sandbox page for Module:String (diff).
See also the companion subpage for test cases (run).

Module documentation[view] [edit] [history] [purge]

[画像:Warning] This Lua module is used in system messages, and on approximately 13,800,000 pages, or roughly 21% of all pages.
Changes to it can cause immediate changes to the Wikipedia user interface.
To avoid major disruption and server load, any changes should be tested in the module's /sandbox or /testcases subpages, or in your own module sandbox. The tested changes can be added to this page in a single edit. Please discuss changes on the talk page before implementing them.

This module is rated as ready for general use. It has reached a mature state, is considered relatively stable and bug-free, and may be used wherever appropriate. It can be mentioned on help pages and other Wikipedia resources as an option for new users. To minimise server load and avoid disruptive output, improvements should be developed through sandbox testing rather than repeated trial-and-error editing.

This module can only be edited by administrators because it is transcluded onto one or more cascade-protected pages.

Module:String (edit | talk | history | links | watch | logs)

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 (19).
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/testcases.

len

This function returns the length of the target string.

Usage:

{{#invoke:String|len|target_string}}

OR

{{#invoke:String|len|s= target_string }}

Parameters:

s: The string whose length to report

Examples:

{{#invoke:String|len| abcdefghi }} → 11
{{#invoke:String|len|s= abcdefghi }} → 9

sub

This function returns a substring of the target string at specified inclusive, one-indexed indices.

Usage:

{{#invoke:String|sub|target_string|start_index|end_index}}

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. To avoid error messages, use {{#invoke:ustring|sub}} instead.

Examples:

"{{#invoke:String|sub| abcdefghi }}" → " abcdefghi "
"{{#invoke:String|sub|s= abcdefghi }}" → "abcdefghi"
"{{#invoke:String|sub| abcdefghi | 3 }}" → "bcdefghi "
"{{#invoke:String|sub|s= abcdefghi |i= 3 }}" → "cdefghi"
"{{#invoke:String|sub| abcdefghi | 3 | 4 }}" → "bc"
"{{#invoke:String|sub|s= abcdefghi |i= 3 |j= 4 }}" → "cd"

sublength

This function implements the features of {{str sub old }} and is kept in order to maintain these older templates. It returns a substring of the target string starting at a specified index and of a specified length.

Usage:

{{#invoke:String|sublength|s= target_string |i= start_index |len= length }}

Parameters:

s: The string
i: The starting index of the substring to return. The first character of the string is assigned an index of 0.
len: The length of the string to return, defaults to the last character.

Examples:

{{#invoke:String|sublength|s= abcdefghi }} → abcdefghi
{{#invoke:String|sublength|s= abcdefghi |i= 3 }} → defghi
{{#invoke:String|sublength|s= abcdefghi |i= 3 |len= 4 }} → defg

match

This function returns a substring from the source string that matches a specified pattern.

Usage:

{{#invoke:String|match|source_string|pattern_string|start_index|match_number|plain_flag|nomatch_output}}

OR

{{#invoke:String|match|s= source_string |pattern= pattern_string |start= start_index |match= match_number |plain= plain_flag |nomatch= nomatch_output }}

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: Boolean flag indicating that pattern should be understood as plain text and not as a Scribunto ustring pattern (a unicode-friendly Lua-style regular expression). Defaults to false (to change: plain=true)
nomatch: If no match is found, output the "nomatch" value rather than an error.
ignore_errors: If no match is found and ignore_errors=true, output an empty string rather than an error.

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:

Examples:

{{#invoke:String|match| abc123def456 |%d+}} → 123
{{#invoke:String|match|s= abc123def456 |pattern= %d+ }} → 123
{{#invoke:String|match| abc123def456 |%d+|6}} → 23
{{#invoke:String|match|s= abc123def456 |pattern= %d+ |start= 6 }} → 3
{{#invoke:String|match|s= abc123def456 |pattern= %d+ |start= 6 |match= 2 }} → 456
{{#invoke:String|match|s= abc123%d+ |pattern= %d+ }} → 123
{{#invoke:String|match|s= abc123%d+ |pattern= %d+ |plain= true }} → %d+
{{#invoke:String|match|s= abc |pattern= %d }} → String Module Error: Match not found
{{#invoke:String|match|s= abc |pattern= %d |nomatch= No numeric characters in string }} → No numeric characters in string
{{#invoke:String|match|s= abc |pattern= %d |ignore_errors= true }} →
{{#invoke:String|match|s= 0012001200 |pattern= 0*(%d*) }} → 12001200

pos

This function returns a single character from the target string at position pos.

Usage:

{{#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

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.

Examples:

{{#invoke:String|pos| abcdefghi | 4 }} → c
{{#invoke:String|pos|target= abcdefghi |pos= 4 }} → d

str_find

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 separately.

Usage:

{{#invoke:String|str_find|source_string|target_string}}

OR

{{#invoke:String|str_find|source= source_string |target= target_string }}

Parameters:

source: The string to search
target: The string to find within source

Examples:

{{#invoke:String|str_find| abc123def }} → 1
{{#invoke:String|str_find|source= abc123def }} → 1
{{#invoke:String|str_find| abc123def |123}} → 5
{{#invoke:String|str_find|source= abc123def |target= 123 }} → 4
{{#invoke:String|str_find| abc123def |not}} → -1

find

This function allows one to search for a target string or pattern within another string.

Usage:

{{#invoke:String|find|source_string|target_string|start_index|plain_flag}}

OR

{{#invoke:String|find|source= source_string |target= target_string |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 Scribunto ustring pattern (a unicode-friendly Lua-style regular expression); defaults to true

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.

Examples:

{{#invoke:String|find|abc123def|12}} → 4
{{#invoke:String|find|source=abc123def|target=12}} → 4
{{#invoke:String|find|source=abc123def|target=pqr}} → 0
{{#invoke:String|find| abc123def |123}} → 5
{{#invoke:String|find|source= abc123def |target= 123 }} → 4
{{#invoke:String|find|source=abc123def|target=%d |start=3 |plain=false }} → 4

When using unnamed parameters, preceding and trailing spaces are kept and counted:

{{#invoke:String|find| abc123def |c|false}} → 5
{{#invoke:String|find|source= abc123def |target=c|plain=false}} → 3
{{#invoke:string|find|abc 123 def|%s|plain=false}} → 4

Testing for the presence of a string:

{{#ifexpr:{{#invoke:string|find|haystack|needle}}|Found needle|Didn't find needle}} → Didn't find needle

findpagetext

The findpagetext function returns the position of a piece of text in the wikitext source of a page. It takes up to four parameters:

First positional parameter or |text is the text to be searched for.
Optional parameter |title is the page title, defaults to the current page.
Optional parameter |plain is either true for a plain search (default), or false for a Lua pattern search.
Optional parameter |nomatch is the value returned when no match is found; default is nothing.

Examples: {{#invoke:String |findpagetext |text=Youghiogheny}} →; {{#invoke:String |findpagetext |text=Youghiogheny |nomatch=not found}} → not found; {{#invoke:String |findpagetext |text=Youghiogheny |title=Boston Bridge |nomatch=not found}} → 373; {{#invoke:String |findpagetext |text=river |title=Boston Bridge |nomatch=not found}} → not found; {{#invoke:String |findpagetext |text=[Rr]iver |title=Boston Bridge |plain=false |nomatch=not found}} → 386; {{#invoke:String |findpagetext |text=%[%[ |title=Boston Bridge |plain=f |nomatch=not found}} → 371; {{#invoke:String |findpagetext |text=%{%{[Cc]oord |title=Boston Bridge |plain=f |nomatch=not found}} → 2553

The search is case-sensitive, so Lua pattern matching is needed to find river or River. The last example finds {{coord and {{Coord. The penultimate example finds a wiki-link.

The Template:Findpagetext is a convenience wrapper for this function.

replace (gsub)

Note that by default the pattern is understood as plain text as the plain flag |plain= defaults to true. To use a Scribunto mw.ustring pattern you must set it to false.

This function allows one to replace a target string or pattern within another string. To Lua programmers: this function works internally by calling mw.ustring.gsub .

Usage:

{{#invoke:String|replace|source_str|pattern_string|replace_string|replacement_count|plain_flag}}

OR

{{#invoke:String|replace|source= source_string |pattern= pattern_string |replace= replace_string |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 occurrences to replace; defaults to all
plain: Boolean flag indicating that pattern should be understood as plain text and not as a Scribunto ustring pattern (a unicode-friendly Lua-style regular expression); defaults to true

Examples:

"{{#invoke:String|replace| abc123def456 |123|XYZ}}" → " abcXYZdef456 "
"{{#invoke:String|replace|source= abc123def456 |pattern= 123 |replace= XYZ }}" → "abcXYZdef456"
"{{#invoke:String|replace| abc123def456 |%d+|XYZ|1|false}}" → " abcXYZdef456 "
"{{#invoke:String|replace|source= abc123def456 |pattern= %d+ |replace= XYZ |count=1 |plain= false }}" → "abcXYZdef456"
"{{#invoke:String|replace|source= abc123def456 |pattern= %d+ |replace= XYZ |plain= false }}" → "abcXYZdefXYZ"
{{#invoke:String|replace|source= 0012001200 |pattern= ^0* |plain= false }} → 12001200

rep

Repeats a string n times. A simple function to pipe string.rep to templates.

Usage:

{{#invoke:String|rep|source|count}}

Parameters:

source: The string to repeat
count: The number of repetitions.

Examples:

"{{#invoke:String|rep|hello|3}}" → "hellohellohello"
"{{#invoke:String|rep| hello | 3 }}" → " hello hello hello "

escapePattern

In a Lua pattern, changes a class character into a literal character. For example: in a pattern, character . catches "any character"; escapePattern will convert it to %., catching just the literal character ".".

Usage:

{{#invoke:String|escapePattern|pattern_string}}

Parameters:

pattern_string: The pattern string to escape

Examples:

"{{#invoke:String|escapePattern|A.D.}}" → "A%.D%."
"{{#invoke:String|escapePattern|10%}}" → "10%%"

count

Counts the number of times a given pattern appears in the arguments that get passed on to this module. Counts disjoint matches only.

Usage:

{{#invoke:String|count|source_str|pattern_string|plain_flag}}

OR

{{#invoke:String|count|source= source_string |pattern= pattern_string|plain= plain_flag }}

Parameters:

source_string: The string to count occurrences in
pattern: The string or pattern to count occurrences of within source
plain: Boolean flag indicating that pattern should be understood as plain text and not as a Scribunto ustring pattern (a unicode-friendly Lua-style regular expression); defaults to true

Examples:

Count of 'a': "{{#invoke:String|count|aabbcc|a}}" → "2"
Count occurrences of 'aba': "{{#invoke:String|count|ababababab|aba}}" → "2"
Count of "either 'a' or 'c' ":"{{#invoke:String|count|aabbcc|[ac]|plain=false}}" → "4"
Count of "not 'a' ": "{{#invoke:String|count|aaabaaac|[^a]|plain=false}}" → "2"
Count of "starts with 'a' ": "{{#invoke:String|count|aaabaaac|^a|plain=false}}" → "1"

join

Joins all strings passed as arguments into one string, treating the first argument as a separator.

Usage:

{{#invoke:String|join|separator|string1|string2|...}}

Parameters:

separator: String that separates each string being joined together; Note that leading and trailing spaces are not stripped from the separator.
string1/string2/...: Strings being joined together

Examples:

"{{#invoke:String|join|x|foo|bar|baz}}" → "fooxbarxbaz"
"{{#invoke:String|join||a|b|c|d|e|f|g}}" → "abcdefg"
"{{#invoke:String|join|,|a|b|c|d|e|f|g}}" → "a,b,c,d,e,f,g"
"{{#invoke:String|join|, |a|b|c|d|e|f|g}}" → "a, b, c, d, e, f, g"
"{{#invoke:String|join| – |a|b|c|d|e|f|g}}" → "a – b – c – d – e – f – g"

The preceding example uses the html entity – but the unicode character also works.

endswith

For the startswith function, see Module:String2 § startswith.

Usage:

{{#invoke:String|endswith|source_str|search_string}}

OR

{{#invoke:String|endswith|source= source_string |pattern= search_string}}

Returns "yes" if the source string ends with the search string. Use named parameters to have the strings trimmed before use. Despite the parameter name, search_string is not a Lua pattern, it is interpreted literally.

"{{#invoke:String|endswith|xxxyyy|y}}" → "yes"
"{{#invoke:String|endswith|xxxyyy|z}}" → ""

See also

{{#invoke:Params|mapping_by_replacing}} and other functions from the same module
{{#invoke:MultiReplace|main}}

v
t
e

String-handling templates (help page)

Substring (select chunk of string by its position)
{{str sub new }} Select a substring based on starting and ending index counted in either direction. {{str left }} Keep the first N characters of a string, or duplicate it to N characters. {{str crop }} Return all but the last N characters of a string. {{str index }} Return the N-th character of a string.		{{str right }} Return substring starting at N-th character to end of string. {{str rightc }} Return the last N characters of a string; or a given value if empty. {{str sub old }} Return substring of given length starting at N-th character.

Trimming (select/remove chunk of string by character type)
{{trim }} Trim any leading or trailing whitespace {{str letter/trim }} Trim down to the beginning letters. {{str number/trim }} Trim down to the beginning numbers. {{trim brackets }} Trim any leading or trailing square brackets. {{trim quotes }} Trim leading or trailing matching quotes. {{trim leading }} Trim up to six instances of specified <prefix>.		{{string split }} Extract a short string from a long string. {{first word }} Trim down to the first space. {{remove first word }} Remove anything before the first space. {{last word }} Trim down from the last space. {{remove last word }} Remove anything after the last space.

Select/remove specific item from string
{{delink }}, {{trim brackets }} Removes wikilink brackets (wikicode); all or outer only. {{Plain text }} Removes wikicode (formatting and brackets) {{PAGENAMEBASE }} Trim off any parenthesis text at the end of a string (disambiguation). {{title disambig text }} Returns text in parentheses at the end of a string (disambiguation).		{{title year }} Returns the 3-or-4-digit year from a pagename, if any. {{title decade }} Returns the 4-digit decade from a pagename (e.g. "1740" from "Foo 1740s bar"), if any. {{title number }} Returns any number from a pagename. {{WikiProjectbasename }} Removes "WikiProject" from a pagename.

Insertion, replacement, and length
{{loop }} Repeat character string a specified number of times. {{replace }} Returns the string, after replacing all occurrences of a specified string with another string. {{str rep }} Returns the string, after replacing the first occurrence of a specified string with another string. {{digits }} Returns the string, after removing all characters that are not digits 0–9 {{Nowiki }} Displays wikitext as plain text.		{{str len }} Returns a string's length. {{str ≥ len }} Check if a string is "longer or equally long" or "shorter" than a given length. {{str ≤ len }} Check if a string is "shorter or equally long" or "longer" than a given length. {{str ≠ len }} Check if a string is "not equal" or "equal" to a given length.

Analysis and searching
{{str startswith }} {{str endswith }} Check if a string starts or ends with a given string. {{str find }}, {{strfind short }} Returns the numerical location of a given string in a string. {{str count }} Count the number of occurrences of a pattern within a string.		{{Array }} Array item manipulation and retrieval. {{a or an }} Takes a noun and produces the appropriate indefinite article, based on whether the first letter is a vowel. {{in string }} Returns optional string when given string is not found {{Isnumeric }} Returns number when true, blank when not numeric. {{str letter }} Returns the number of letters that begin a string. {{str number }} Returns the number of numbers that begin a string.

Modules and built-in functions
Module:String, Module:String2, Module:Ustring, Module:Text, wikitext handling: modules that together contain most necessary string functions. Magic words: About `{{padleft:\|}}`, `{{lc:\|}}`, `{{formatnum:\|}}` etc. ParserFunctions: About `{{#titleparts:\|}}, {{#expr:\|}}, {{#ifeq:\|}},` etc.

Category:String manipulation templates

Category:Modules that manipulate strings

The above documentation is transcluded from Module:String/doc. (edit | history)
Editors can experiment in this module's sandbox (edit | diff) and testcases (edit | run) pages.
Add categories to the /doc subpage. Subpages of this module.

 --[[

 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.
 ]]

 localstr={}

 --[[
 len

 This function returns the length of the target string.

 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.
 ]]
 functionstr.len(frame)
 localnew_args=str._getParameters(frame.args,{'s'})
 locals=new_args['s']or''
 returnmw.ustring.len(s)
 end

 --[[
 sub

 This function returns a substring of the target string at specified indices.

 Usage:
 {{#invoke:String|sub|target_string|start_index|end_index}}
 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.
 ]]
 functionstr.sub(frame)
 localnew_args=str._getParameters(frame.args,{'s','i','j'})
 locals=new_args['s']or''
 locali=tonumber(new_args['i'])or1
 localj=tonumber(new_args['j'])or-1

 locallen=mw.ustring.len(s)

 -- Convert negatives for range checking
 ifi<0then
 i=len+i+1
 end
 ifj<0then
 j=len+j+1
 end

 ifi>lenorj>lenori<1orj<1then
 returnstr._error('String subset index out of range')
 end
 ifj<ithen
 returnstr._error('String subset indices out of order')
 end

 returnmw.ustring.sub(s,i,j)
 end

 --[[
 This function implements that features of {{str sub old}} and is kept in order
 to maintain these older templates.
 ]]
 functionstr.sublength(frame)
 locali=tonumber(frame.args.i)or0
 locallen=tonumber(frame.args.len)
 returnmw.ustring.sub(frame.args.s,i+1,lenand(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
 functionstr._match(s,pattern,start,match_index,plain_flag,nomatch)
 ifs==''then
 returnstr._error('Target string is empty')
 end
 ifpattern==''then
 returnstr._error('Pattern string is empty')
 end
 start=tonumber(start)or1
 ifmath.abs(start)<1ormath.abs(start)>mw.ustring.len(s)then
 returnstr._error('Requested start is out of range')
 end
 ifmatch_index==0then
 returnstr._error('Match index is out of range')
 end
 ifplain_flagthen
 pattern=str._escapePattern(pattern)
 end

 localresult
 ifmatch_index==1then
 -- Find first match is simple case
 result=mw.ustring.match(s,pattern,start)
 else
 ifstart>1then
 s=mw.ustring.sub(s,start)
 end

 localiterator=mw.ustring.gmatch(s,pattern)
 ifmatch_index>0then
 -- Forward search
 forwiniteratordo
 match_index=match_index-1
 ifmatch_index==0then
 result=w
 break
 end
 end
 else
 -- Reverse search
 localresult_table={}
 localcount=1
 forwiniteratordo
 result_table[count]=w
 count=count+1
 end

 result=result_table[count+match_index]
 end
 end

 ifresult==nilthen
 ifnomatch==nilthen
 returnstr._error('Match not found')
 else
 returnnomatch
 end
 else
 returnresult
 end
 end

 --[[
 match

 This function returns a substring from the source string that matches a
 specified pattern.

 Usage:
 {{#invoke:String|match|source_string|pattern_string|start_index|match_number|plain_flag|nomatch_output}}
 OR
 {{#invoke:String|match|s=source_string|pattern=pattern_string|start=start_index
  |match=match_number|plain=plain_flag|nomatch=nomatch_output}}

 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.

 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
 functionstr.match(frame)
 localnew_args=str._getParameters(frame.args,{'s','pattern','start','match','plain','nomatch'})
 locals=new_args['s']or''
 localstart=tonumber(new_args['start'])or1
 localplain_flag=str._getBoolean(new_args['plain']orfalse)
 localpattern=new_args['pattern']or''
 localmatch_index=math.floor(tonumber(new_args['match'])or1)
 localnomatch=new_args['nomatch']

 returnstr._match(s,pattern,start,match_index,plain_flag,nomatch)
 end

 --[[
 pos

 This function returns a single character from the target string at position pos.

 Usage:
 {{#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.
 ]]
 functionstr.pos(frame)
 localnew_args=str._getParameters(frame.args,{'target','pos'})
 localtarget_str=new_args['target']or''
 localpos=tonumber(new_args['pos'])or0

 ifpos==0ormath.abs(pos)>mw.ustring.len(target_str)then
 returnstr._error('String index out of range')
 end

 returnmw.ustring.sub(target_str,pos,pos)
 end

 --[[
 str_find

 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.
 ]]
 functionstr.str_find(frame)
 localnew_args=str._getParameters(frame.args,{'source','target'})
 localsource_str=new_args['source']or''
 localtarget_str=new_args['target']or''

 iftarget_str==''then
 return1
 end

 localstart=mw.ustring.find(source_str,target_str,1,true)
 ifstart==nilthen
 start=-1
 end

 returnstart
 end

 --[[
 find

 This function allows one to search for a target string or pattern within another
 string.

 Usage:
 {{#invoke:String|find|source_str|target_string|start_index|plain_flag}}
 OR
 {{#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.
 ]]
 functionstr.find(frame)
 localnew_args=str._getParameters(frame.args,{'source','target','start','plain'})
 localsource_str=new_args['source']or''
 localpattern=new_args['target']or''
 localstart_pos=tonumber(new_args['start'])or1
 localplain=new_args['plain']ortrue

 ifsource_str==''orpattern==''then
 return0
 end

 plain=str._getBoolean(plain)

 localstart=mw.ustring.find(source_str,pattern,start_pos,plain)
 ifstart==nilthen
 start=0
 end

 returnstart
 end

 --[[
 replace

 This function allows one to replace a target string or pattern within another
 string.

 Usage:
 {{#invoke:String|replace|source_str|pattern_string|replace_string|replacement_count|plain_flag}}
 OR
 {{#invoke:String|replace|source=source_string|pattern=pattern_string|replace=replace_string|
  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
 ]]
 functionstr.replace(frame)
 localnew_args=str._getParameters(frame.args,{'source','pattern','replace','count','plain'})
 localsource_str=new_args['source']or''
 localpattern=new_args['pattern']or''
 localreplace=new_args['replace']or''
 localcount=tonumber(new_args['count'])
 localplain=new_args['plain']ortrue

 ifsource_str==''orpattern==''then
 returnsource_str
 end
 plain=str._getBoolean(plain)

 ifplainthen
 pattern=str._escapePattern(pattern)
 replace=string.gsub(replace,"%%","%%%%")--Only need to escape replacement sequences.
 end

 localresult

 ifcount~=nilthen
 result=mw.ustring.gsub(source_str,pattern,replace,count)
 else
 result=mw.ustring.gsub(source_str,pattern,replace)
 end

 returnresult
 end

 --[[
  simple function to pipe string.rep to templates.
 ]]
 functionstr.rep(frame)
 localrepetitions=tonumber(frame.args[2])
 ifnotrepetitionsthen
 returnstr._error('function rep expects a number as second parameter, received "'..(frame.args[2]or'')..'"')
 end
 returnstring.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.
 ]]
 functionstr.escapePattern(frame)
 localpattern_str=frame.args[1]
 ifnotpattern_strthen
 returnstr._error('No pattern string specified')
 end
 localresult=str._escapePattern(pattern_str)
 returnresult
 end

 --[[
 count
 This function counts the number of occurrences of one string in another.
 ]]
 functionstr.count(frame)
 localargs=str._getParameters(frame.args,{'source','pattern','plain'})
 localsource=args.sourceor''
 localpattern=args.patternor''
 localplain=str._getBoolean(args.plainortrue)
 ifplainthen
 pattern=str._escapePattern(pattern)
 end
 local_,count=mw.ustring.gsub(source,pattern,'')
 returncount
 end

 --[[
 endswith
 This function determines whether a string ends with another string.
 ]]
 functionstr.endswith(frame)
 localargs=str._getParameters(frame.args,{'source','pattern'})
 localsource=args.sourceor''
 localpattern=args.patternor''
 ifpattern==''then
 -- All strings end with the empty string.
 return"yes"
 end
 ifmw.ustring.sub(source,-mw.ustring.len(pattern),-1)==patternthen
 return"yes"
 else
 return""
 end
 end

 --[[
 join

 Join all non empty arguments together; the first argument is the separator.
 Usage:
 {{#invoke:String|join|sep|one|two|three}}
 ]]
 functionstr.join(frame)
 localargs={}
 localsep
 for_,vinipairs(frame.args)do
 ifsepthen
 ifv~=''then
 table.insert(args,v)
 end
 else
 sep=v
 end
 end
 returntable.concat(args,sepor'')
 end

 -- findpagetext returns the position of a piece of text in a page
 -- First positional parameter or |text is the search text
 -- Optional parameter |title is the page title, defaults to current page
 -- Optional parameter |plain is either true for plain search (default) or false for Lua pattern search
 -- Optional parameter |nomatch is the return value when no match is found; default is nil
 functionstr._findpagetext(args)
 -- process parameters
 localnomatch=args.nomatchor""
 ifnomatch==""thennomatch=nilend
 --
 localtext=mw.text.trim(args[1]orargs.textor"")
 iftext==""thenreturnnilend
 --
 localtitle=args.titleor""
 localtitleobj
 iftitle==""then
 titleobj=mw.title.getCurrentTitle()
 else
 titleobj=mw.title.new(title)
 end
 --
 localplain=args.plainor""
 ifplain:sub(1,1)=="f"thenplain=falseelseplain=trueend
 -- get the page content and look for 'text' - return position or nomatch
 localcontent=titleobjandtitleobj:getContent()
 returncontentandmw.ustring.find(content,text,1,plain)ornomatch
 end
 functionstr.findpagetext(frame)
 localargs=frame.args
 localpargs=frame:getParent().args
 fork,vinpairs(pargs)do
 args[k]=v
 end
 ifnot(args[1]orargs.text)thenreturnnilend
 -- just the first value
 return(p._findpagetext(args))
 end
 --[[
 Helper function that populates the argument list given that user may need to use a mix of
 named and unnamed parameters. This is relevant because named parameters are not
 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.
 ]]
 functionstr._getParameters(frame_args,arg_list)
 localnew_args={}
 localindex=1
 localvalue

 for_,arginipairs(arg_list)do
 value=frame_args[arg]
 ifvalue==nilthen
 value=frame_args[index]
 index=index+1
 end
 new_args[arg]=value
 end

 returnnew_args
 end

 --[[
 Helper function to handle error messages.
 ]]
 functionstr._error(error_str)
 localframe=mw.getCurrentFrame()
 localerror_category=frame.args.error_categoryor'Errors reported by Module String'
 localignore_errors=frame.args.ignore_errorsorfalse
 localno_category=frame.args.no_categoryorfalse

 ifstr._getBoolean(ignore_errors)then
 return''
 end

 localerror_str='<strong class="error">String Module Error: '..error_str..'</strong>'
 iferror_category~=''andnotstr._getBoolean(no_category)then
 error_str='[[Category:'..error_category..']]'..error_str
 end

 returnerror_str
 end

 --[[
 Helper Function to interpret boolean strings
 ]]
 functionstr._getBoolean(boolean_str)
 localboolean_value

 iftype(boolean_str)=='string'then
 boolean_str=boolean_str:lower()
 ifboolean_str=='false'orboolean_str=='no'orboolean_str=='0'
 orboolean_str==''then
 boolean_value=false
 else
 boolean_value=true
 end
 elseiftype(boolean_str)=='boolean'then
 boolean_value=boolean_str
 else
 error('No boolean value found')
 end
 returnboolean_value
 end

 --[[
 Helper function that escapes all pattern characters so that they will be treated
 as plain text.
 ]]
 functionstr._escapePattern(pattern_str)
 return(string.gsub(pattern_str,"[%(%)%.%%%+%-%*%?%[%^%$%]]","%%%0"))
 end

 returnstr

Retrieved from "https://en.wikipedia.org/w/index.php?title=Module:String/sandbox&oldid=1305419240"

Module sandboxes