Template talk:Str ≥ len

Template:Str ≥ len is permanently protected from editing because it is a heavily used or highly visible template. Substantial changes should first be proposed and discussed here on this page. If the proposal is uncontroversial or has been discussed and is supported by consensus, editors may use {{edit template-protected}} to notify an administrator or template editor to make the requested edit. Usually, any contributor may edit the template's documentation to add usage notes or categories.

Any contributor may edit the template's sandbox. This template does not have a testcases subpage. You can create the testcases subpage here.

To help centralize discussions and keep related topics together, Template talk:Str ≤ len, Template talk:Str ≠ len and Template talk:Str ≤ ≥ len redirect here.

Some notes about the code

I created these templates since there are cases when we would like to automatically make for instance a small message box wider, or even make it large again, if it is fed a long text. See for instance Template talk:Expand-section#New style too narrow.

{{str ≥ len}} is the most efficient of these templates, compared to {{str ≤ len}}, {{str ≠ len}} and {{str ≤ ≥ len}}. That is, {{str ≥ len}} uses less code as in less parser functions. But all these "string length comparison templates" are pretty efficient, so I think we don't need to worry about performance. (But there are other string handling templates out there that are scary...)

While building and testing these templates I noticed a bug in the {{padleft}} magic word / parser function. When we don't feed padleft a "separator" parameter (the third/last parameter to it), then it correctly defaults to pad with zeros. But if padleft gets an empty string as the separator parameter it fails to pad. Here are some examples:

{{padleft:a|3}}

{{padleft:a|3|}} = Fails to pad.

{{padleft:a|3| 0 }}

{{padleft:a|3| {{{1|}}} }} = Fails to pad.

{{padleft:a|3| {{#if:{{{1|}}}|{{{1|}}}|0}} }} = My workaround.

00a

a = Fails to pad.

00a

a = Fails to pad.

00a = My workaround.

I had to apply that workaround to {{str ≠ len}} to make that template work correctly when fed empty strings. (It might look like {{str ≤ len}} and {{str ≤ ≥ len}} also would need that workaround, but they don't since they never provoke the bug.)

--David Göthberg (talk) 01:37, 25 March 2009 (UTC)[reply]

I just noticed a thing I had forgot about: ifeq and switch-cases are too smart, they understand numbers. So I had to add "x" in front of the strings so they are not interpreted as numbers. But then we need to remove any whitespace around the strings, or it becomes "x 01234" instead of "x01234", thus I had to use "{{#if:x| }}" at some places. This means that now these string length comparison templates correctly understand that a string such as "01234" is 5 characters.

--David Göthberg (talk) 11:44, 26 March 2009 (UTC)[reply]

So that the code is slightly more readable, can I suggest "{{#if:ltrim| }}" instead. Mark Hurd (talk) 04:24, 25 June 2009 (UTC)[reply]

These are fantastic templates. The code is so short but they are so incomprehensible :) Nice work. — Martin (MSGJ · talk) 19:15, 18 April 2009 (UTC)[reply]

Thanks. But I didn't do the invention of using the magic word padleft for length comparisons. Other editors did that long before me and I learnt from them. I just used it to build some of these templates.

--David Göthberg (talk) 23:33, 18 April 2009 (UTC)[reply]

String lengths

This discussion moved here from my talk page since I think it might be useful as reference for other users of these templates. --David Göthberg (talk) 23:33, 18 April 2009 (UTC)[reply]

Hi, I've just been admiring your string length templates and I have a question.

When using characters with accents, it seems that two bytes are needed sometimes. Therefore the length of a string is not always the number of its bytes. Therefore the following code can sometimes say "not equal":

{{str ≠ len|{{TALKPAGENAME}}|{{PAGESIZE:{{TALKPAGENAME}}}}|Not equal!}}

I'm wondering if there is any way of

counting the number of bytes used for a string; or
comparing the length of two different strings.

What I am actually trying to do is to determine when a page is a redirect to a particular page. If it is, it's normally 14 bytes more than the string length, but that only works without accents as far I can see!

Many thanks, — Martin (MSGJ · talk) 19:30, 18 April 2009 (UTC)[reply]

Oh dear, it took me quite some thinking and testing before I understood what it is you want to do. This is complicated stuff...

1: Two bytes per character with accents? Yes, some Unicode characters even take more than two bytes. The padleft magic word we use for the string length functions always counts characters. While the {{PAGESIZE}} magic word counts bytes. I did a test with a page only containing this: "≥≥≥≥≥≥≥≥≥≥". We humans see 10 characters there, and {{str len}} says that is 10 characters, but {{PAGESIZE}} says that is 30 characters. Apparently the character "≥" takes 3 bytes to store.

In template programming we have no way of doing string length comparisons that give us the number of bytes in the string. We can only get the number of characters. And as far as I know we have no way of getting the number of characters on a redirect page, only the number of bytes. So there is no way we can do the comparison you want to do if the page name of the page redirected to contains special characters. Sorry.

But we can do what you want to do for page names that only contain old 1 byte ASCII characters. (Mainly the English alphabet and numbers and some other simple symbols.) I had already written down most of the below explanation before I understood your problem, so I might just as well share it. Here goes:

2: Sometimes these templates measure the length of the code they get, and sometimes they measure the length of the rendered output of that code. That is, for some things the MediaWiki parser runs the str len template without parsing the string fed to it. And sometimes MediaWiki first parses the string fed, and then parses the str len template. So lets check how it handles the magic word you want to use.

{{TALKPAGENAME}} = 16 characters:

{{TALKPAGENAME}} expanded on this page becomes "Template talk:Str ≥ len" = 23 characters.

{{str len| {{TALKPAGENAME}} }}

{{str ≠ len | {{TALKPAGENAME}} | 23
| Not equal.
| Equal.
}}

23

Equal.

Seems the MediaWiki parser first expands the magic word, and then runs the str len template. And that is what we want in your case. So all good in this part.

3: Your comparison code is wrong. Here's how to do it (but it only works for pagenames with simple 1 byte ASCII characters):

You are right that the redirect code without the page name is 14 characters:

#REDIRECT [[]] = 14 characters.

If the page Template:Str len full redirects to Template:Str len, then it might contain this code:

#REDIRECT [[Template:Str len]] = 30 characters.

Note that the pagename it has in its code is not its own pagename, but the name of the page it points to. (That is one of the bugs in your code, you compare with the wrong names.) So the page name inside the redirect is:

Template:Str len = 16 characters.

What we want to compare is this:

If (length of pagename of the page redirected to == length of page content of the redirect page - 14) then it is a redirect page.

And here is the code for that:

{{str ≠ len | Template:Str len | {{#expr: {{PAGESIZE:Template:Str len full}} - 14 }}
| Not equal. It's not a redirect.
| Equal. It's a redirect.
}}

Equal. It's a redirect.

Look at that, it works! But it only works provided there are no extra data on the redirect page, like the {{R from}} templates...

Compare with the "correct" code to check if Template talk:Str ≤ ≥ len is a redirect to this talkpage:

{{str ≠ len | Template talk:Str ≥ len | {{#expr: {{PAGESIZE:Template talk:Str ≤ ≥ len}} - 14 }}
| Not equal. It's not a redirect.
| Equal. It's a redirect.
}}

Not equal. It's not a redirect.

That is the wrong answer, since Template talk:Str ≤ ≥ len is a redirect to this talk page. But since the name has a 3-byte Unicode character in it the comparison fails.

So MSGJ, it seems there are too many cases when such a comparison fails. So even though I don't know exactly what it is you want to do, my guess is that this is too complex for template programming to handle. Sorry.

--David Göthberg (talk) 23:33, 18 April 2009 (UTC)[reply]

Thanks for the long and detailed answer! I did indeed make an error, but it was only in my paraphrasing the question to attempt to make it clearer that I blundered, for I indeed have something very similar to your code above with -14 in Template:AFC submission/onhold which is the template I've been working on, although I have increased it slightly to -18 to allow for a few extra bytes. The only thing you haven't answered is whether or not it is possible to compare two string lengths. For then I could use "length" for both and would not need to deal with byte counts. — Martin (MSGJ · talk) 07:49, 19 April 2009 (UTC)[reply]

Ah yeah, I see your code in {{AFC submission/onhold}} seems better. (But I just took a very quick look.) And yeah, giving the comparison some margin seems a good approach.

And sorry, in your case you can't compare two text-string lengths, since you can't use {{str len}} to get the length of a redirect page. (For anyone else reading this: Text-string length as compared to byte length.)

But normally you can compare two string lengths. Just use {{str len}} to get the number of characters in each string and then use {{#expr:}} to do whatever comparisons and math you want on those numbers. But {{str len}} costs much more server resources than the string length comparison templates, so using the others are better and usually also simpler.

But now that I have seen the code of {{AFC submission/onhold}} I am curios: What kind of page is that template to be put on? And why do you want to check if the talk page is redirected? And where do you expect the redirect to point to?

--David Göthberg (talk) 15:21, 19 April 2009 (UTC)[reply]

Thanks again for the answer. So if I'm understanding things right, if page X is a redirect to page Y then there is no way to transclude the contents of X because {{X}} will result in the contents of Y? Yes the situation is a little strange. All AfC submissions are created on pages in the Wikipedia talk namespace (because unregistered users can do that). However, we occasionally want to move it to the subject page so that we can use the talk page for discussing the submission! This template will alert viewers that there is non-trivial content on the talk page of a submission. — Martin (MSGJ · talk) 18:04, 19 April 2009 (UTC)[reply]

Yes, that's the reason. Your transclusion conclusion is exactly right, unfortunately.

Ah, so that's how you are going to use it. Very nifty!

--David Göthberg (talk) 22:41, 19 April 2009 (UTC)[reply]

Edit request to complete TfD nomination

This edit request to Template:Str ≤ ≥ len has been answered. Set the |answered= or |ans= parameter to no to reactivate your request.

Template:Str ≤ ≥ len has been listed at Templates for discussion (nomination), but was protected so could not be tagged. Please add:

{{subst:template for discussion|help=off}}

to the top of the page to complete the nomination. Thank you. User:GKFX^talk 10:19, 6 April 2021 (UTC)[reply]

Done with |type=disabled, because this looks to be a widely-used technical utility template. Elli (talk | contribs) 11:37, 6 April 2021 (UTC)[reply]

Oops, wrong template. Done now on the correct one, displaying ofc. Elli (talk | contribs) 11:39, 6 April 2021 (UTC)[reply]

"Template:Str = len" listed at Redirects for discussion

A discussion is taking place to address the redirect Template:Str = len. The discussion will occur at Wikipedia:Redirects for discussion/Log/2021 April 26#Template:Str = len until a consensus is reached, and readers of this page are welcome to contribute to the discussion. User:GKFX^talk 07:15, 26 April 2021 (UTC)[reply]