This template looks for a word in a comma-separated list of words. It returns a True (found) or False (not found) value.

By default, the True-value returned is the found word itself; the False-value is a blank string.

{{Str find word |source=alpha, foo, bar |word=foo}} (True) → foo
{{Str find word |source=alpha, foo, bar |word=nov}} (False)

No partial fit. Partial word matching do not count as a hit:

{{Str find word |source=alpha, foobar, bar |word=foo}} (False)

Case-sensitive: By default, the comparison is case-sensitive (Foo ≠ foo); all text is turned into lowercase. One can make the check case-sensitive by |case=true

{{Str find word |source=alpha, Foo, bar |word=foo |case=false}} (True) → foo
{{Str find word |source=alpha, Foo, bar |word=foo |case=true}} (False)


Using this template, the editor does not have to apply patterns ('%f[^,][^,]+%f[,]'). No return value interpretation is required (like when 1 then do x), though is optionally possible. There is no inbetween-result: the logic says it is either T or F. The logic can not result in an error.

options

edit

The True and False return values can be set through |yes=, |no=:

{{Str find word |source=alpha, foo, bar |word=foo |yes=Yesss |no=Nooo}} (True) → Yesss
{{Str find word |source=alpha, foo, bar |word=nov |yes=Yesss |no=Nooo}} (False) → Nooo

Specifics

edit
Words
A 'word' is the character string between commas. This can be all characters and inner spaces:
{{Str find word |source=alpha, foo bar sunday, bar |word=foo bar sunday}} (True) → foo bar sunday
{{Str find word |source=alpha, bar(22) [take care]!, foo |word=bar(22) [take care]!}} (True) → bar(22) [take care]!
Return value
True- and False-value can be set through |yes=, |no=:
{{Str find word |source=alpha, foo, bar |word=foo |yes=Yesss |no=Nooo}} (True) → Yesss
{{Str find word |source=alpha, foo, bar |word=nov |yes=Yesss |no=Nooo}} (False) → Nooo
Boolean value read
Setting |booleans=true will read common bolean words as boolean (true, false).
Boolean words for true: 'True', 'T', 'Yes', '1'. False: 'False', 'F', 'No', '0'. Boolean words are always case-insensistive (True=true).
{{Str find word |source=alpha, yes, bar |word=true |booleans=true}} (True) → true
{{Str find word |source=alpha, false, bar |word=0 |booleans=true}} (True) → false
{{Str find word |source=alpha, false, bar |word=0 |booleans=false}}(default) (False)

Word lists

edit

The word list |source= is comma-separated. Prefixed and suffixed spaces are discarded (trimmed).

alpha, foo, bar
Inner spaces are kept, and are part of the 'word':
alpha, foo, hello world, bar
Any character apart from ⟨,⟩ comma can be part of the word:
α(12) [mind the gap]!, foo, hello world, bar
Multiple spaces (whitespace) inside a string is reduced to a single space:
alpha,  foo    bar, 
equals alpha, foo bar,
Spaces ⟨ ⟩, Comma ⟨,⟩, quote ⟨"⟩, pipe ⟨|⟩
Trimmed spaces
All words are trimmed before checking (leading and trailing whitespace is removed; repeated inner whitespaces are reduced to one space):
{{Str find word |source=alpha , hello   world, foo |word=hello world}} (True) → hello world
...but the remaining in-word space does matter:
{{Str find word |source=alpha, hello   world, foo |word=helloworld}} (False)


Comma ⟨,⟩
When a comma ⟨,⟩ is part of the word to check. Word strings that contain a comma can be made literal (escape the comma):
Red XN TODO check this doc claim {{Str find word |source=alpha, "hello, world", foo |word="hello, world"}} (True) → "hello,world"
??chk: {{Str find word |source=alpha, "hello, world", foo |word="hello, world"|literals=false}} (True) → "hello,world"
??chk: {{Str find word |source=alpha, "hello, world", foo |word="hello, world"|literals=true}} (True) → "hello,world"
Quote character ⟨"⟩
Conversely, quote characters ⟨"⟩ that are part of the word are escaped by setting |literals=false:
{{Str find word |source=alpha, she said "hello world", "foo" |word=she said "hello world" |literals=false}} (True) → she said "hello world"
Pipe ⟨|⟩
The pipe character can be entered as {{!}}
{{Str find word |source=alpha, hello{{!}}world, foo |word=hello{{!}}world }} (True) → hello|world

Checking multiple words

edit

It is possible to check multiple words against the source wordlist.

AND-words to check
|andwords=: can have a wordlist (comma-separated as |source= is). Each word will be checked against the source. When all and-words are found, the return value is True.
{{Str find word |source=alpha, beta, gamma, foo, bar |andwords=alpha, foo}} (True) → alpha,foo
{{Str find word |source=alpha, beta, gamma, foo, bar |andwords=bar, foo, beta, alpha}} (True) → bar,foo,beta,alpha
{{Str find word |source=alpha, beta, gamma, foo, bar |andwords=alpha, nov}} (False)
OR-words to check
|orwords=: can have a wordlist (comma-separated as |source= is). Each word will be checked against the source. When a single or-words is found, the return value is True. Default True return value is the list with all words found.
{{Str find word |source=alpha, beta, gamma, foo, bar |orwords=alpha, foo}} (True) → alpha
{{Str find word |source=alpha, happy, gamma, nice, foo, bar |orwords=april, sad, happy, ugly, nice}} (True) → happy,nice
{{Str find word |source=alpha, happy, gamma, nice, foo, bar |orwords=sad, ugly, november}} (False)
Both AND-words, OR-words to check
|andwords=, :|orwords= can be used together. Each wordlist will get its own logical checks (AND-words must all be present; OR-words at least one)
T: {{Str find word |source=alpha, beta, april, gamma, foo, happy |andwords=alpha, beta |orwords=april, november, sad, ugly}} (True) → alpha,beta,april
{{Str find word |source=alpha, beta, april, gamma, foo, happy |andwords=alpha, november |orwords=april, november, sad, ugly}} (False)

Examples

edit
|source= |word= result note
|source=alpha, foo, lima |word=foo foo Green tickY
|source=alpha, foo, lima |word=nov Red XN
|source=alpha, uc-all |word=uc-all uc-all Green tickY
|source=alpha, hello world_, bar |word=hello world_ hello world_ Green tickY The comma is the word-delimiter
|source=alpha,foo   bar , lima |word=  foo   bar foo bar Green tickY Spaces are trimmed, multi-space into one space
|source=alpha, foo bar, lima |word=foobar Red XN An inner space is a character too
|source=alpha, FOO, bAr, lima |word=bar, foo Green tickY Not case-sensistive by default
|source=alpha, FOO, bAr, lima |word=bar, foo Red XN |case=true: case-sensistive

note

edit
The editor does not have to apply Lua patterns like [%a%d]*
The editor does not have to interpret the return value (as in: "when ='blue' then ..."). They can prescribe the value even (yes-value, no-value).

Usage

edit

Basic

edit

Core function:

{{Str find word
|source =
|word  =
|yes  =
|no   =
}}
When the word is found in the source (True), the function returns the word itself (by default), or |yes= value (when entered non-empty).
When not found (False), the function returns an empty string (''), or the |no= value when entered.
|source= |word= result note
|source=alpha, foo, lima |word=foo foo Green tickY
|source=alpha, uc-all |word=uc-all uc-all Green tickY "-" (hyphen) is part of the word
|source=alpha, do_something, white |word=do_something do_something Green tickY "_" (underscore) is part of the word
|source=alpha, foo, lima |word=november Red XN
|source=alpha, foobar, lima |word=foo Red XN 'foo' is not the complete word
|source=alpha, foo, lima |word= Red XN no |word= entered
|source=alpha, foo, lima |word=foobar No, not found Red XN full word foo-bar not in the source
|source=alpha, foo, lima |word=foobar No, not found Red XN word foo not in the source as full word
... |yes=Yes, hit |no=Not found
|source=alpha, foo, lima |word=foo Yes, hit Green tickY
|source=alpha, foo, lima |word=foobar No, not found Red XN

All parameters

edit
All parameters, in three options
{{Str find word
|string = 
|word  =
|allwords =
|orwords = 
|case=
|yes =
|no =
|explain =
}}
{{Str find word
|s  = 
|w  =
|allw=
|orw =
|case=
|yes =
|no =
|explain =
}}
{{Str find word |s= |w= |allw= |orw= |case= |yes= |no= |explain=}}

More options

edit
|source=
|s= |1=
|word=
|w= |2=
|case= result note
|s=alpha, foo, lima |w=foo yes
|s=alpha, foo, lima |w=foobar no
|s=alpha, foobar, lima |w=foo no 'foo' is not the complete word
|s=alpha, FOO, lima |w=foo yes |case=false: a=A (default)
|s=alpha, FOO, lima |w=foo no |case=true: a=/=A

word list

edit
Instead of a single word to check, a list of target words can be entered: |word=alpha, foo, bingo. This |word=-list will be treated with AND-logic: each and all of the words must be present. See:

AND-, OR-wordlist checks

edit
|word= as noted, can be a list of words. all will be checked with the AND-requirement (each word must be present).
|andwords= accepts a list of words that all will be checked with the AND-requirement (each word must be present).
When both |word=, |andwords= are present, they are combined into one single AND-wordlist.
|orwords= accepts a list of words that all will be checked with the OR-requirement (at least one of the words must be present).

Errors and analysis

edit
  • The logic itself does not produce errors. There is always a True of False result.
There are no logical errors foreseen: any flaw in the input will return a False result (for example, no input strings to check were entered).
  • |explain=true: when in Preview, display a report on input, output and the logical steps (debug).
  • |explain=testcases: When set in ns Template or User on subpage /testcases, the Preview report is static (shown permanently).

See also

edit