Help:Sorting: Difference between revisions

From Meta, a Wikimedia project coordination wiki
Content deleted Content added
DieBuche (talk | contribs)
Updating doc for MW 1.18. PLEASE REVERT TO THIS VERSION ONCE 1.18 IS DEPLOYED. (unless I remember to do it in time)
Line 3: Line 3:


A sortable table is identified by the arrows in each of its header cells. Clicking them will cause the table rows to sort based on the selected column, in ascending order first, and subsequently toggling between ascending and descending order. Links and other wiki-markup are not possible in headers.
A sortable table is identified by the arrows in each of its header cells. Clicking them will cause the table rows to sort based on the selected column, in ascending order first, and subsequently toggling between ascending and descending order. Links and other wiki-markup are not possible in headers.

Note that all of the below is subject to change due to improvements in the script.


==JavaScript==
==JavaScript==
The JavaScript code [http://svn.wikimedia.org/viewvc/mediawiki/trunk/phase3/skins/common/wikibits.js?view=log wikibits.js] has on each site a copy at
The JavaScript code [http://svn.wikimedia.org/viewvc/mediawiki/trunk/phase3/resources/jquery/jquery.tablesorter.js?view=markup jquery.tablesorter.js (source)] of the tablesorter is loaded by the ResourceLoader. Some sites may have a page [[MediaWiki:Common.js]] which adds and overrides some code.
<nowiki>{{SERVER}}/skins-1.5/common/wikibits.js</nowiki>, on this site {{SERVER}}/skins-1.5/common/wikibits.js. In addition a site may have a page [[MediaWiki:Common.js]] which adds and overrides some code.


==Sort modes==
==Sort modes==
The way items are sorted depends on the [[w:data type|data type]] of the item ''currently'' in the first row. To determine the data type, the following tests are made in order, until one matches. Thus, if "24-12-2007" is the first item, then all items will be compared as dates.
The way items are sorted depends on the [[w:data type|data type]] of the item ''currently'' in the first row. To determine the data type, multiple cells are tested and the most appropriate format is chosen. Mismatches are possible, but can be easily corrected by manually specifying <code>data-sort-type</code> inside the header of the respective row:


<pre>{|class="wikitable sortable"
To force an item to match as text, use the "sms" template, e.g. <code><nowiki>{{sms|101 Dalmatians}}</nowiki></code>
! data-sort-type="date" | Date!!Name!!Height
|-
|01.10.1977||Smith||1.85
|-
|11.6.1972||Ray||1.89
|-
|1.9.1992||Bianchi||1.72
|}</pre>

The following (case-insensitive) values are valid for data-sort-type:
*text
*number
*IPAdress
*currency
*url
*isoDate
*usLongDate
*date
*time


Unfortunately, there's no way to force an item to sort as numeric or date without using custom sort keys (generally by using formatting templates): if the item on the first row to sort does not match a supported format, it will be treated as text, and all the column will be sorted as text, possibly changing the content of the item on the first row so that it will apparently be of a distinct type.
:: ''Proposal: we could allow every cells of the table heading row to specify the expected sort mode for all cells on their column. This could be done easily by adding a class attribute on this heading cell, such as class="sort-as-text", class="sort-as-number", or class="sort-as-date", so that the Javascript code would no longer need to ''guess'' the data type of the cell content in the first sortable row. This would also remove the need to use custom key formatting in every data cell to make sure that it will sort as expected.''
Tags such as ''span'' or ''sup'' are ignored when determining data type.
Tags such as ''span'' or ''sup'' are ignored when determining data type.
# Date (see also below)
#* Criterion: the first non-blank element is of the form "dd-dd-dddd", "dd-dd-dd", or "dd aaa dddd"
#* Order: if wgContentLanguage != "en" then string "abcdefghij" of length 10 is positioned as "ghijdeab", the string "abcdefghijk" of length 8 as "19ghdeab" if "gh">="50" (string comparison) and "20ghdeab" otherwise (i.e., the assumed format is "DD-MM-YYYY" or "DD-MM-YY"), and the string "dd aaa dddd" with "aaa" an abbreviated month name: chronologically.
#*: ''Proposed internationalisation: month names (or abbreviations) are recognized only in their English form, using only the 3 first letters. There's no way to specify another language/locale which would use incompatible abbreviations, some of them being ambiguous if only 3 characters are considered, such as ''juin'' (June) vs. ''juillet'' (July) in French, where only some months will be recognized correctly. Also dates in ISO format "YYYY-MM-DD" are not recognized correctly.'' For other languages than English, custom hidden sort keys still need to be specified in every cell containing such date formats.
# "Currency" (this mode can be useful for other data also)
#* Criterion: the first non-blank element starts with $, £, €, or ¥
#* Order: numeric, ignoring these symbols and all ordinary letters and commas, but not spaces; note that scientific notation cannot be used, as e and E are removed
# Numeric
#*Criterion: the first non-blank element consists of just digits, points, commas, spaces, "+", "-", possibly followed by "e" or "E" and a string consisting of "+", "-", digits
#*Order: after removing the commas and spaces, if any, if the string starts with a number the order is numeric according to the first number in the string ([http://www.devguru.com/technologies/ecmascript/QuickRef/parsefloat.html parseFloat] is applied); it is regarded as zero if it is empty; in other cases (parseFloat returns [[w:NaN|NaN]]), the element is positioned like -∞.
#*: ''Proposed internationalisation: in German etc., treat comma as a decimal point''
# Text (default)
#* Criterion: all other cases; to avoid one of the other modes, start e.g. with a hidden "&"; this can be done conveniently with {{tim|sms}}, which also allows more hidden text, as sortkey; while the similar templates above are called at the end of a table element, call this one at the start
#* Order: after conversion of capitals to lowercase the order is [[w:ASCII|ASCII]] – actually the order is binary, based on [[UTF-16]] code unit values, because this is the way strings compare natively in [[Javascript]]. But some browser ''may ''use their own locale-specific ordering when comparing strings, depending on user's locale preference. There is for now no way to specify a locale explicitly that Javascript can use.
#: Partial list showing the order: <code>!"#$%&'()*+,-./09:;<=>?@[\]^_'az{|}~é&mdash;</code>
#:(see also below; a blank space comes before every other character; an [[w:Non-breaking space|nbsp]] code ''may'' count as a space in some browsers; two adjacent ordinary blank spaces count as one; for multiple blank spaces one can use nbsps or alternate nbsps and ordinary blank spaces)


===Dates===
After sorting, the data type may change, since there is a new item in the first row. This can lead to a cycle of four or even more instead of two. As this is confusing, try and avoid this situation by making sure that every element matches the criterion for the required data type. Using a {{ml|Help:Table|Row_template|row template}} helps.
Various date formats are supported, including those with localized month names.
On the German Wikipedia, "16. März 2010" is correctly sorted as 2010-05-16


Most other numerical formats are supported as well, including those with different separators (such as . , ' or / );
An alternative method of making sure the sort mode of each column is as desired, is creating a first row that determines the sort modes, but in such a way that this row is not displayed and is excluded from sorting, see below.
On English Wikipedias dates are treated as US-Dates (eg. month-day-year) per default.


== Examples ==
===Numbers===
The script can recognize numbers with different decimal separators (. and ,) as well as e/E numbers.
The script sees what the cells contains at the first data row. The sorting mode becomes '''numeric''' if the cell of the first data row contains ''number only'' (comma and full-stop used in number formatting are accepted as number). The sorting order will work properly even though other cells contains text ''after'' numbers (e.g. "200 approx"). Empty cell is treated as "zero" when sorting numerically.



It is sorted ascendingly first, and then descendingly. However bear in mind that the cell of the first data row will change accordingly after sorting. If that cell no longer contains number only after sorting, the sorting mode will change. For example, if the cell of the first data row becomes "200 approx" after sorting, this will make the sorting mode '''alphabetic'''.
===Text===
Text is sorted in [[w:ASCII|ASCII]] order (Any accented/special characters follow after the basic latin alphabet). This can be changed site wide by posting code like the following inside the common.js:
<pre>
mw.config.set('tableSorterCollation', {'ä':'ae', 'ö' : 'oe', 'ß': 'ss', 'ü':'ue'});
</pre>
Afterwards, all 'ä' will be sorted as if they were an ae etc.
Partial list showing the default order: <code>!"#$%&'()*+,-./09:;<=>?@[\]^_'az{|}~é&mdash;</code>

== Examples ==


{|
{|
Line 379: Line 388:
Sometimes it is helpful to exclude the last row of a table from the sorting process.
Sometimes it is helpful to exclude the last row of a table from the sorting process.


This can be achieved using <code>class="sortbottom"</code> on the desired table row (line starting with <code>|-</code>).
This can be achieved by declaring the last row as a footer


'''Wiki markup'''
'''Wiki markup'''
Line 391: Line 400:
<nowiki>|-</nowiki>
<nowiki>|-</nowiki>
<nowiki>|</nowiki>Mario||Bianchi||1.72
<nowiki>|</nowiki>Mario||Bianchi||1.72
<nowiki>|-</nowiki><b style="color:red">class="sortbottom"</b>
<nowiki>|-</nowiki>
<nowiki>|</nowiki>||Average:||1.82
<b style="color:red">! !!</b>Average:||1.82
<nowiki>|}</nowiki>
<nowiki>|}</nowiki>


Line 405: Line 414:
|-
|-
|Mario||Bianchi||1.72
|Mario||Bianchi||1.72
|-class="sortbottom"
|||Average:||1.82
|}

More generally, one or more lines at the bottom marked with <code>class="sortbottom"</code> are sorted among themselves, but stay at the bottom. Thus it is not possible to keep multiple lines fixed at the bottom:

{|class="wikitable sortable"
|+''Using more than one "sortbottom", failing to keep these lines fixed''
!Name!!Surname!!Height
|-
|-
|John||Smith||1.85
!!!Average:||1.82
|-
|Ron||Ray||1.89
|-class="sortbottom"
|||Average:||1.82
|-class="sortbottom"
!Name!!Surname!!Height
|}
|}


==== Excluding the first row from sorting ====
==== Excluding the first row from sorting ====
The same can be applied for first rows as well, by declaring them as header using the same exclamation mark notation.

As follows from what was mentioned above, the first row of a table can be made non-sortable (the code <code><s>class="sorttop"</s></code> not being valid) by marking every other row except the first with <code>class="sortbottom"</code>. This first row can either be a normal visible row (to provide annotation for the headers) or a hidden row (with each element marked with <code><nowiki><span style="display:none">...</span></nowiki></code>) to ensure that each column has the desired sort mode.


=== Making a column unsortable ===
=== Making a column unsortable ===
Line 446: Line 439:
<nowiki>|-</nowiki>
<nowiki>|-</nowiki>
<nowiki>|</nowiki>5||V||05/12/2006||7.15||See?
<nowiki>|</nowiki>5||V||05/12/2006||7.15||See?
<nowiki>|-</nowiki>class="sortbottom"
<nowiki>|-</nowiki>
<nowiki>!</nowiki>Total: 15!!!!!!Total: 29.55!!
<nowiki>!</nowiki>Total: 15!!!!!!Total: 29.55!!
<nowiki>|-</nowiki>
<nowiki>|-</nowiki>
Line 465: Line 458:
|-
|-
|5||V||05/12/2006||7.15||See?
|5||V||05/12/2006||7.15||See?
|-
|-class="sortbottom"
!Total: 15!!!!!!Total: 29.55!![http://www.joostdevalk.nl/code/sortable-table/ Original example]
!Total: 15!!!!!!Total: 29.55!![http://www.joostdevalk.nl/code/sortable-table/ Original example]
|-
|-
|}
|}


== Correcting a wrongly parsed cell ==
=== Striping ===
Sometimes the value of a cell is not correctly parsed or one wants to sort the row in a special way. (e.g. a cell containing 'John Doe' should actually be sorted as 'Doe' and not as 'John')
The JavaScript that makes tables sortable can add <code>.odd</code> and <code>.even</code> classes to the rows of the resulting table.
This can be easily achieved by manually setting <pre>data-sort-value</pre>


'''Wiki markup'''
As of August 2010, this feature is '''disabled by default''' (<code>var ts_alternate_row_colors = false;</code> in [[svn:trunk/phase3/skins/common/wikibits.js|wikibits.js]]) and can be enabled with the line <code>ts_alternate_row_colors = true;</code> in the local Common.js.


<nowiki>{|class="wikitable sortable"
If a [[w:Wikipedia:Catalogue of CSS classes|cascading style sheet]] specifies that text be displayed differently in these two classes, alternating rows in the resulting table will appear differently. For example, including the following code in a style sheet causes ''every'' sortable table to have silver and gold background stripes:
!Name and Surname!!Height
<pre>
|-</nowiki>
tr.odd {
|<b style="color:red">data-sort-value="Smith"</b>|John Smith||1.85
background-color: silver;
|-
}
|<b style="color:red">data-sort-value="Ray"</b>|Ian Ray||1.89
tr.even {
|-
background-color: gold;
|<b style="color:red">data-sort-value="Bianchi"</b>|Zachary Bianchi||1.72
}
|-
</pre>
!Average:||1.82

|}
It is also possible to define an <code>id</code> in a CSS that causes only tables with that <code>id</code> to be striped, for example:
<pre>
#stripe tr.odd {
background-color: silver;
}
#stripe tr.even {
background-color: gold;
}
</pre>
In this case, only tables with <code>class="sortable"</code> ''and'' <code>id="stripe"</code> would display with alternating row colors.

If a user sorts the table according to a different column, the stripes still alternate. I.e., the stripes are specific to the positions of the rows in the sorted table, not to the positions of the rows in the wikitext.

==Sorting with hidden sortkey==
=== Basic CSS-based solution ===
If necessary one can apply sorting using a sortkey which [[Help:Cascading_style_sheets#Non-display|due to CSS is not displayed]]:
:<nowiki><span style="display:none">...</span></nowiki>

Example:
:<nowiki>p<span style="display:none">q</span>r</nowiki> gives p<span style="display:none">q</span>r

Javascript sorting is based on the text inside and outside the tags, without the tags themselves. A hidden sortkey can be put at the start. Both in the case of alphabetic and that of numeric sorting the first parts determine the order. Both parts together are used to determine the sort mode, so for numeric sorting the whole should be a valid number.

=== Invisible separator needed between an hidden sortkey and the visible text ===
Caution: this technic above depends on the fact that the plain-text extracted from the HTML is an effective prefix order. When multiple strings are sorted with some of them starting with the same prefix which is also the full plain-text value of another one, you may not get the expected sort order. See for example :

#<nowiki><span style="display:none">ab</span>ab</nowiki> gives: <span style="display:none">ab</span>ab
#<nowiki><span style="display:none">aba</span>aba</nowiki> gives: <span style="display:none">aba</span>aba

When the plain-text is extracted, the HTML markup tags are dropped (as well as HTML comments), then leading and trailing whitespaces are trimmed (and others are collapsed) keeping only:
#abab
#abaaba
Then when these strings are sorted, the first line will sort '''after''' the second line, despite its specified "sort key" (ab) was designed to be lower than the sort key for the second line (aba).

A solution is to insert between the invisible sort key and the visible string after it some character sequence that will sort lower than any ''reasonable'' visible text that may occur after the generated invisible sort key.

=== Choice of the separator ===
Note that the client-side javascript that will extract those plain-text strings from the HTML can only see the text after it has been cleaned from extra spaces. Also spaces starting or ending spans are implicitly ''tidied'' by the MediaWiki HTML generator so that there's no way to place a final space at end of the sort key. In other words, a space alone (or any equivalent string after HTML fixup (space conversion and compression) will not work alone as a separator, as it will become part of the visible string.

In addition, you may want to sort two strings like "Foo", and "Foo Bar". If you generate sortkeys for them you would get:
# Foo Foo
# Foo Bar Foo Bar
And once again there's no way to make any distinction between the embedded space that is part of a sort key or part of the visible string, and the space used to separate them. We need instead a sequence like "*" so that "Foo*Foo" < "Foo Bar*Foo Bar". It must be the smallest string that sorts before the visible text encoded after it. We've seen that the space alone does not work as desired. Also, we cannot use any control character, because HTML does not allow controls (except tabs and newlines, that are implicitly converted to space in the HTML DOM) in conforming HTML document. The smallest string that exists after the space alone is "SPACE+EXCLAMATION" (if we use binary sorting, but as well if we use a DUCET-based collator). If we use an exclamation mark alone, it would be too high, because the exclamation mark is also likely to occur as part of the visible text: when sorting "a" and "a!" we would compare:
: "a<span style="background:yellow">!</span>a" > "a!<span style="background:yellow">!</span>a!"
so that "a" will sort after "a!". If we use SPACE+EXCLAMATION, this problem disappears:
: "a<span style="background:yellow">&nbsp;!</span>a" < "a!<span style="background:yellow">&nbsp;!</span>a!".

Another problem will then occur is we use SPACE+EXCLAMATION without specific marking, because MediaWiki implicitly converts a space before an exclamation mark into a non-breaking space (NBSP), whose binary value will be too high. One way to avoid the problem is to say to MediaWiki to not attempt to modify the text of the key separator, by making "!" as a regular plain-text character. This also avoid MediaWiki of reinterpreting the exclamation mark as a wiki-syntax markup (notably for delimiting table cells).

So the complete solution is to write:
#<code><nowiki><span style="display:none"></nowiki>ab<span style="background:yellow">&nbsp;&lt;nowiki&gt;!&lt;/nowiki&gt;</span><nowiki></span>ab</nowiki></code> gives: <span style="display:none">ab <nowiki>!</nowiki></span>ab
#<code><nowiki><span style="display:none"></nowiki>aba<span style="background:yellow">&nbsp;&lt;nowiki&gt;!&lt;/nowiki&gt;</span><nowiki></span>aba</nowiki></code> gives: <span style="display:none">aba <nowiki>!</nowiki></span>aba
Do not forget the space between the sort key and the "nowiki" section containing the exclamation mark !

Example in a simple sortable table, using here the same invisible sort key as the plain text for simplicity, and various invisible separators (all columns are displaying the same visible text on each row, and use the same sort key, columns are different only by the choice of the key separator: only the last column using SPACE+EXCLAMATION sorts as desired, including within the HTML DOM exposed to the Javascript code):


'''What it looks like in your browser'''
{|class="wikitable sortable"
{|class="wikitable sortable"
!Name and Surname!!Height
|-
|-
|data-sort-value="Smith"|John Smith||1.85
!scope="col" class="unsortable"| Case
!scope="col"| Test using no separator
!scope="col"| Test using SPACE alone
!scope="col"| Test using EXCLAMATION alone
!scope="col"| Test using SPACE+EXCLAMATION
|-
|-
|data-sort-value="Ray"|Ian Ray||1.89
!scope="row"| 1
| <span style="display:none">ab</span>ab
| <span style="display:none">ab </span>ab
| <span style="display:none">ab!</span>ab
| <span style="display:none">ab <nowiki>!</nowiki></span>ab
|-
|-
|data-sort-value="Bianchi"|Zachary Bianchi||1.72
!scope="row"| 2
| <span style="display:none">ab ab</span>ab ab
| <span style="display:none">ab ab </span>ab ab
| <span style="display:none">ab ab!</span>ab ab
| <span style="display:none">ab ab <nowiki>!</nowiki></span>ab ab
|-
|-
!Average:||1.82
!scope="row"| 3
| <span style="display:none">ab!</span>ab!
| <span style="display:none">ab! </span>ab!
| <span style="display:none">ab!!</span>ab!
| <span style="display:none">ab! <nowiki>!</nowiki></span>ab!
|-
!scope="row"| 4
| <span style="display:none">aba</span>aba
| <span style="display:none">aba </span>aba
| <span style="display:none">aba!</span>aba
| <span style="display:none">aba <nowiki>!</nowiki></span>aba
|-
!scope="row"| 5
| <span style="display:none">aba aba</span>aba aba
| <span style="display:none">aba aba </span>aba aba
| <span style="display:none">aba aba!</span>aba aba
| <span style="display:none">aba aba <nowiki>!</nowiki></span>aba aba
|-
!scope="row"| 6
| <span style="display:none">z</span>z
| <span style="display:none">z </span>z
| <span style="display:none">z!</span>z
| <span style="display:none">z <nowiki>!</nowiki></span>z
|}
|}


===Keeping some rows together===
Note: The table is sorted initially here in the expected sort order (so the case numbers should be linearily counted after sorting on a column). This demo still does not differentiate the cases with SPACE alone or with SPACE+EXCLAMATION, only because the sort keys are always equal here to the visible text. The difference will be visible when the hidden sort keys are completely different from the visible text.
data-sort-value can be used to keep certain rows together. The original mutual order of these rows is preserved.


Example where this is the case for the rows about the Netherlands:
This technic will only fail in one case: when the visible text (or the invisible sort key) may contain an exclamation mark after a space immediately followed by a non-space character. This case never occurs in normal Latin text with correct typographic rules (if the exclamation mark is followed by something else, it should be some whitespace before anything else), except in specific notations not used for human languages (like computer languages, or notations using the exclamation mark as if it was a letter, such as non-IPA phonetic notations, here the exclamation mark is used instead of the regular IPA symbol for noting a click before other phonetic symbols in the same word).


Notes:
* HTML restricts the set of usable characters that will be exposed in the HTML DOM after parsing (this is needed for strict performance as well as for compatibility with transport layers or storage systems and editor/convertor tools. However, such restriction does not apply to strings built and handled internally in Javascript variables or arrays, as long as they are not part of the DOM (i.e. not stored as text elements, element names, attribute names or as attribute values). A more convenient key separator that could be used in Javascript would then be the smallest usable control character U+0001 (the null character may also be used in some implementations but not all). But this cannot be specified in Wiki pages, because MediaWiki restricts the possibility of inserting random Javascript code in the HTML page.
*The same separator used to separate the sort key from the visible text can also be used to separate multi-level sort keys (for UCA-like collation algorithms) or to build compound keys (built from successive fields in a row of data); if both are needed simultaneously, the separator for compound keys should be lower than the separator for UCA-like multi-level key separators (but another option is to generate UCA-like multilevel keys so that higher levels get encoded with a separate binary subset of codes/characters than the subset of codes/characters needed for lower levels including the primary level, so that no separator is needed for multilevel sort keys whose separation is implicit according to the value range where each used code/character belongs; this is the technic used in the DUCET, the Default Unicode Collation Element Table, which does not require any separator, but still allows a reserved collation weight 1 to be used as a compound key separator for sorting multi-field data rows).

==Alphabetic sorting with hidden sortkey==
The sortkey comes at the start and is separated from the displayed text in such a way that the latter does not affect the sorting order. For example, if a sortkey system is used where there are no blank spaces in any sortkey, then a blank space can be used for separation. If a single blank space ''is'' possible in a sortkey, two nbsps can be used. For table elements for which the text to be displayed is equal to the sortkey, no duplication is needed, of course.

If the text inside and outside the tags together is of a form that would cause a sorting mode other than alphabetic (if and when the element is at the top), a character can be appended at the end of the sortkey to avoid this, again making sure it does not affect the sorting order by putting a space or two nbsps. This can be dispensed with if the element can never be at the top, but this can be complicated to assess as that can be caused by sorting other columns, with varying sorting modes, and it can change when deleting a row, adding a column, etc.

Instead of "display=none" another way is using a font color equal to the background, e.g. <nowiki><font color="#f9f9f9">999</font></nowiki> gives "<font color="#f9f9f9">999</font>". With this method the hidden code can be seen in selected text (e.g. with the mouse). Also the hidden text is included when copying the rendered text. The first may be an advantage or a disadvantage, the second seems only a disadvantage. A complication is also that if a user uses a background color different from the default, the specified text color may not match it; to make sure they are the same the background color can be specified also.

===Unsuitability of padding with no-break spaces===
The effect of left-padding with [[w:Non-breaking space|"&amp;nbsp;" codes]], which render as blank spaces, depends on the browser: in IE they are (unlike actual blank spaces) counted for sorting as leading blank spaces, so in a list of numbers with text (for which the alphabetic sorting mode applies) they could be used to equalize the number of characters before the explicit or implicit decimal separator. However, in Firefox they are ignored for the purpose of sorting.

{|class="wikitable sortable"
!Sorting using nbsps, works on IE but not on Firefox
!Name
|-
|100.3 FM
|Third
|-
|&nbsp;89.5 FM
|First
|-
|107.3 FM
|Fourth
|-
|&nbsp;95.3 FM
|Second
|}

See also [[:en:Talk:List of U.S. states and territories by population/Archive 1#Sortable Table]].

===Padding with zeros===
Example:
*{{padleft:{{#expr:12*13}}|6|0}}

Formatnum can be combined with padleft:

Integer:

<nowiki>{{formatnum:{{padleft:299792458|16|0}}}}</nowiki> gives:

*{{formatnum:{{padleft:299792458|16|0}}}}

Real:

<nowiki>{{formatnum:{{padleft:{{#expr:((299792458.056 - .5) round 0)}}|16|0}}}}.{{padleft:{{#expr:(1000000*(299792458.056 - ((299792458.056 - .5) round 0))) round 0}}|6|0}}</nowiki> gives:

*{{formatnum:{{padleft:{{#expr:((299792458.056 - .5) round 0)}}|16|0}}}}.{{padleft:{{#expr:(1000000*(299792458.056 - ((299792458.056 - .5) round 0))) round 0}}|6|0}}

===Alphabetic sortkey for numeric sorting===
If one needs to use alphabetic sort mode for numbers, one can construct a hidden alphabetic sortkey for this purpose. To make sure that alphabetic sort mode is used no code should satisfy the criterion for numeric sorting mode. Although this matters only for the element at the top, any element might arrive at the top due to sorting another column. Alphabetic sort mode can for example be achieved by starting all sortkeys with "&". It prevents numbers with a remark, or texts like N/A to affect sorting, and allows any choice for their sortkeys.

In the case of non-negative numbers with known upper limit (i.e., even if the table may need editing in the future the numbers are expected to remain below this limit) the sortkey can be "&" followed by the number with leading zeros. For example, in a table column with non-negative numbers below 1,000,000 the sort key of 23.4 is &000023.4

====General case====
: To allow a wide range numbers (between -1e100 and 1e100) the following system can for example be used:
:* where scientific notation is used, it is normalized such that the absolute value of the mantissa is between 1 and 10; the exponent is put first
:* scientific notation is used for all negative numbers, and all positive numbers outside some interval (below: 1e-9 to 1e9), and not inside that interval
:* where the absolute value of the exponent and/or the mantissa is a decreasing function of the number, the notation uses its complement with respect to 99 for exponents and 10 for mantissas; the code "c" is added in these cases
:* numbers 0 &le; ''x'' < 1000 get a "+" in front
:* positive numbers in scientific notation with a negative exponent get "+0" in front
:* spaces inside the code and &-signs in front are added where needed:
:** for numbers not in scientific notation the positions of all explicit and implicit decimal points are aligned
:** for the starting position, i.e. the position of the first "-", "+", or "e", of other numbers, see the example table
:** to avoid numeric sorting mode, below we have always either an ampersand or two letters e
:In the following the left column shows the code for alphabetic sorting, where cryptic followed by the regular notation. The second column contains the same (hence sorting the same), but with code hidden with CSS. The third column does not contain hidden parts and uses numeric sort mode. When sorting the first or second column "more than 1e9" is positioned suitably, while when sorting the third column it is positioned like 0. Moreover, if this cell would be at the top alphabetic sort mode would be used.
::{|class="wikitable sortable"
|-
!total of hidden and displayed text!! display form !!plain number!!compact sort key of other method
|-
|<tt>{{lsc11amp|6|}} </tt>||{{lsc11amp|6}} || 6 || 3000_6
|-
|<tt>{{lsc11amp|7|}} </tt>||{{lsc11amp|7}} || 7 || 3000_7
|-
|<tt>{{lsc11amp|{{#expr: 4^10}}|}} </tt>||{{lsc11amp|{{#expr: 4^10}}}} || {{formatnum:{{#expr: 4^10}}}} || 3006_1048576
|-
|<tt>{{lsc11amp|1234|}} </tt>|||{{lsc11amp|1234}} || 1,234 || 3003_1234
|-
|<tt>{{lsc11amp|123|}} </tt>||{{lsc11amp|123}} || 123 || 3002_123
|-
|<tt>{{lsc11amp|{{#expr: 4^12}}|}} </tt>||{{lsc11amp|{{#expr: 4^12}}}} || {{formatnum:{{#expr: 4^12}}}} || 3007_16777216
|-
|<tt>{{lsc11amp|{{#expr: 4^8}}|}} </tt>||{{lsc11amp|{{#expr: 4^8}}}} || {{formatnum:{{#expr: 4^8}}}} || 3005_65536
|-
|<tt>{{lsc11amp|{{#expr: 4^13}}|}} </tt>||{{lsc11amp|{{#expr: 4^13}}}} || {{formatnum:{{#expr: 4^13}}}} || 3007_67108864
|-
|<tt><span>e23 6</span> 6e23 </tt>||<span style="display:none">e23 6</span> 6e23 || 6e23 || 3023_6
|-
|<tt><span>e09 1.01</span> more than 1e9 </tt>||<span style="display:none">e09 1.01</span> more than 1e9 || more than 1e9 || 3009_101
|-
|<tt><span>e09 1</span> 1e9 </tt>||<span style="display:none">e09 1</span> 1e9 || 1e9 || 3009_1
|-
|<tt><span>&&&&&&&&&+0 ec89 9.999,99 </span> 9.999,99e-10</tt>||{{sms|&&&&&&&&+0 ec89 9.999,99 }} 9.999,99e-10|| 9.999,99e-10 || 2990_999999
|-
|<tt><span>&&&&&&&&&+</span>0.000,000,001 </tt>||<span style="display:none">&&&&&&&&&+</span>0.000,000,001 || 0.000,000,001 || 2991_1
|-
|<tt><span>&&&&&&&&&+0 ec87 6 </span>6e-12</tt>||<span style="display:none">&&&&&&&&&+0 ec87 6 </span>6e-12|| 6e-12 || 2988_6
|-
|<tt><span>&&&&&&&&&+0 ec86 7 </span>7e-13</tt>||<span style="display:none">&&&&&&&&&+0 ec86 7 </span>7e-13|| 7e-13 || 2987_7
|-
|<tt><span>&&&&&&&&&+0 ec87 5 </span> 5e-12</tt>||<span style="display:none">&&&&&&&&&+0 ec87 5 </span> 5e-12|| 5e-12 || 2988_5
|-1
|<tt><span>&&&&&&&&&&-e-10 c0.000,01</span> -9.999,99e-10 </tt>||<span style="display:none">&&&&&&&&&&-e-10 c0.000,01</span> -9.999,99e-10 || -9.999,99e-10 || 1010_000001
|-
|<tt><span>&&&&&&&&&&-e-08 c6.8 </span> -3.2e-8</tt>||<span style="display:none">&&&&&&&&&&-e-08 c6.8 </span> -3.2e-8|| -3.2e-8 || 1008_68
|-
|<tt><span>&&&&&&&&&&&-ec86 c0.3 </span> -9.7e13</tt>||<span style="display:none">&&&&&&&&&&&-ec86 c0.3 </span> -9.7e13|| -9.7e13 || 0987_03
|-
|<tt><span>&&&&&&&&&&&-ec99 c7.7 </span> -2.3</tt>||<span style="display:none">&&&&&&&&&&&-ec99 c7.7 </span> -2.3|| -2.3 || 1000_77
|-
|<tt>{{lsc11amp|0|}} </tt>||{{lsc11amp|0}} || 0 || 2000_
|-
|<tt>{{lsc11amp|0|}}.3 </tt>||{{lsc11amp|0}}.3 || 0.3 || 2999_3
|}

An advantage of this method is that for a range of positive numbers for which scientific notation is often not common, no separate sortkey is needed, just invisible &-signs and in some case a plus sign are added in front. When using a template to produce both the invisible and the visible text this advantage may not be important.

In the following method the sort code is more compact.
: A simpler algorithm may be used to generate shorter sort keys for arbitrarily large or small numbers of arbitrary precision; this algorithm can be easily implemented in templates from any computed value:
:* Write numbers in normalized scientific notation (with 1 <= mantissa < 10, except when number is zero, or NaN, or infinite : see table below).
:* Compute the following three groups of digits:
:* 1. Write a first digit depending on the signs of the number or of the normalized exponent:</li></ol>
::{|class="wikitable"
|-
! Sign of number !! Sign of normalized exponent !! Number value range !! First group to select
|-
|rowspan="2"| negative || positive || -Infinite < x &le; -10 ||bgcolor="#FDD"| 0
|-
| negative or null || -10 < x < 0 ||bgcolor="#CFC"| 1
|-
|rowspan="2"| positive or null || negative || +0 &le; x < +1 ||bgcolor="#EEF"| 2
|-
| positive or null || +1 &le; x < +Infinite ||bgcolor="#FFF"| 3
|}
:* 2. Take the absolute value of the normalized exponent. Then if the sign-digit above is 0 or 2 and if the number is not null, transform the exponent by substracting this absolute value from 1000 (i.e. take the complement to 9 of all digits, then add 1 to the resulting integer). Write the transformed exponent as a group with fixed length of 3 digits (if you need larger exponents, use 10000 for 4 digits, and so on).
:* 3. If the sign-digit (computed from table above) is 0 or 1 (i.e. the number is strictly negative), substract the absolute value of the normalized mantissa from 10 (take to the complement to 9 of all digits, then add 1 to the integer formed by dropping the decimal separator on the second position). Write the resulting integer as a third group of digits (you ''may'' drop that dot from the group)
:* The groups of digits need to be separated in such a way that it cannot be confused as a number or a date: a good separator is the underscore, but groups may just be comma-separated as well. Only one separator is needed (because the two first groups have a fixed length), but it is suggested to use it between all three groups, or at least between the second and third group (even if this one is empty). In the table below, both kinds of separators are visible, to make things clearer.
:* As this format has no limitation on the precision of the mantissa, you may append other characters (including unnecessary trailing zeroes from the mantissa) that are needed to sort related informations (such as "more than", "less than") in an additional group.
: Examples are shown in the table below which sorts correctly in the last two columns; this table shows the computed groups and the compacted sort keys when normalized exponents have been written on 3 digits ; all trailing zeroes (or mantissa digits for infinite values), as well as the decimal dot, in the expression of the mantissa have been dropped from the compact sort key:
::{| class="wikitable sortable" style="font-size:80%;line-height:1.1
|-
! Value || Value normalized in<br /> scientific notation !! Computed groups !! Compact sort key
|-bgcolor="#FFF"
| +Infinite || + 10<sup>+ INF</sup> × 1.000 || 4 ; 000 ; 1.000 || 4000_
|-bgcolor="#FFF"
| 9.999e999 || + 10<sup>+ 999</sup> × 9.999 || 3 ; 999 ; 9.999 || 3999_9999
|-bgcolor="#FFF"
| 1e17 || + 10<sup>+ 017</sup> × 1.000 || 3 ; 017 ; 1.000 || 3017_1
|-bgcolor="#FFF"
| 1234 || + 10<sup>+ 003</sup> × 1.234 || 3 ; 003 ; 1.234 || 3003_1234
|-bgcolor="#FFF"
| 234 || + 10<sup>+ 002</sup> × 2.340 || 3 ; 002 ; 2.340 || 3002_234
|-bgcolor="#FFF"
| 34 || + 10<sup>+ 001</sup> × 3.400 || 3 ; 001 ; 3.400 || 3001_34
|-bgcolor="#FFF"
| 10 || + 10<sup>+ 001</sup> × 1.000 || 3 ; 001 ; 1.000 || 3001_1
|-bgcolor="#FFF"
| 9.999 || + 10<sup>+ 000</sup> × 9.999 || 3 ; 000 ; 9.999 || 3000_9999
|-bgcolor="#FFF"
| 8 || + 10<sup>+ 000</sup> × 8.000 || 3 ; 000 ; 8.000 || 3000_8
|-bgcolor="#FFF"
| 2 || + 10<sup>+ 000</sup> × 2.000 || 3 ; 000 ; 2.000 || 3000_2
|-bgcolor="#FFF"
| 1 || + 10<sup>+ 000</sup> × 1.000 || 3 ; 000 ; 1.000 || 3000_1
|-bgcolor="#EEF"
| 0.9999 || + 10<sup>– 001</sup> × 9.999 || 2 ; 999 ; 9.999 || 2999_9999
|-bgcolor="#EEF"
| 0.8 || + 10<sup>– 001</sup> × 8.000 || 2 ; 999 ; 8.000 || 2999_8
|-bgcolor="#EEF"
| 0.2 || + 10<sup>– 001</sup> × 2.000 || 2 ; 999 ; 2.000 || 2999_2
|-bgcolor="#EEF"
| 0.1 || + 10<sup>– 001</sup> × 1.000 || 2 ; 999 ; 1.000 || 2999_1
|-bgcolor="#EEF"
| 0.00002 || + 10<sup>– 001</sup> × 2.000 || 2 ; 995 ; 2.000 || 2995_2
|-bgcolor="#EEF"
| 0.000002 || + 10<sup>– 006</sup> × 2.000 || 2 ; 994 ; 2.000 || 2994_2
|-bgcolor="#EEF"
| 1e-999 || + 10<sup>– 999</sup> × 1.000 || 2 ; 001 ; 1.000 || 2001_1
|-bgcolor="#EEF"
| 0 || + 10<sup>+ 000</sup> × 0.000 || 2 ; 000 ; 0.000 || 2000_
|-bgcolor="#CFC"
| -1e-999 || – 10<sup>– 999</sup> × 1.000 || 1 ; 999 ; 9.000 || 1999_9
|-bgcolor="#CFC"
| -0.000002 || – 10<sup>– 006</sup> × 2.000 || 1 ; 006 ; 8.000 || 1006_8
|-bgcolor="#CFC"
| -0.00002 || – 10<sup>– 005</sup> × 2.000 || 1 ; 005 ; 8.000 || 1005_8
|-bgcolor="#CFC"
| -0.1 || – 10<sup>– 001</sup> × 1.000 || 1 ; 001 ; 9.000 || 1001_9
|-bgcolor="#CFC"
| -0.2 || – 10<sup>– 001</sup> × 2.000 || 1 ; 001 ; 8.000 || 1001_8
|-bgcolor="#CFC"
| -0.8 || – 10<sup>– 001</sup> × 8.000 || 1 ; 001 ; 2.000 || 1001_2
|-bgcolor="#CFC"
| -0.9 || – 10<sup>– 001</sup> × 9.000 || 1 ; 001 ; 1.000 || 1001_1
|-bgcolor="#CFC"
| -0.9001 || – 10<sup>– 001</sup> × 9.001 || 1 ; 001 ; 0.999 || 1001_0999
|-bgcolor="#CFC"
| -0.9999 || – 10<sup>– 001</sup> × 9.999 || 1 ; 001 ; 0.001 || 1001_0001
|-bgcolor="#CFC"
| -1 || – 10<sup>– 000</sup> × 1.000 || 1 ; 000 ; 9.000 || 1000_9
|-bgcolor="#CFC"
| -2 || – 10<sup>– 000</sup> × 2.000 || 1 ; 000 ; 8.000 || 1000_8
|-bgcolor="#CFC"
| -8 || – 10<sup>– 000</sup> × 8.000 || 1 ; 000 ; 2.000 || 1000_2
|-bgcolor="#CFC"
| -9 || – 10<sup>– 000</sup> × 9.000 || 1 ; 000 ; 1.000 || 1000_1
|-bgcolor="#CFC"
| -9.001 || – 10<sup>– 000</sup> × 9.001 || 1 ; 000 ; 0.999 || 1000_0999
|-bgcolor="#CFC"
| -9.999 || – 10<sup>– 000</sup> × 9.999 || 1 ; 000 ; 0.001 || 1000_0001
|-bgcolor="#FDD"
| -10 || – 10<sup>+ 001</sup> × 1.000 || 0 ; 999 ; 9.000 || 0999_9
|-bgcolor="#FDD"
| -11 || – 10<sup>+ 001</sup> × 1.100 || 0 ; 999 ; 8.900 || 0999_89
|-bgcolor="#FDD"
| -34 || – 10<sup>+ 001</sup> × 3.400 || 0 ; 999 ; 6.600 || 0999_66
|-bgcolor="#FDD"
| -34.02 || – 10<sup>+ 001</sup> × 3.402 || 0 ; 999 ; 6.598 || 0999_6598
|-bgcolor="#FDD"
| -34.1 || – 10<sup>+ 001</sup> × 3.410 || 0 ; 999 ; 6.590 || 0999_6590
|-bgcolor="#FDD"
| -234 || – 10<sup>+ 002</sup> × 2.340 || 0 ; 998 ; 7.660 || 0998_7660
|-bgcolor="#FDD"
| -1234 || – 10<sup>+ 003</sup> × 1.234 || 0 ; 997 ; 8.766 || 0997_8766
|-bgcolor="#FDD"
| -9.999e999 || – 10<sup>+ 999</sup> × 9.999 || 0 ; 001 ; 9.999 || 0001_0001
|-bgcolor="#FDD"
| -Infinite || – 10<sup>+ INF</sup> × 1.000 || 0 ; 000 ; 1.000 || 0000_
|}

==Dates==

{|
|-
|
{|class="wikitable sortable"
{|class="wikitable sortable"
!Country/province!!Capital
|-
|-
|France||Paris
!Date sort mode
|-
|-
|Netherlands||Amsterdam
|07 Apr 2007
|-
|-
|data-sort-value=Netherlands|South Holland||data-sort-value=Amsterdam|The Hague
|16 Apr 2007
|-
|-
|U.K.||London
|16 Mar 2007
|-
|05-04-2007
|-
|04-05-2007
|-
|18 Mar 2007
|-
|27 Mar 2007
|-
|20 Aug 2006
|-
|22 Jul 2006
|}
|}


==Special dates==
|-
|
{|class="wikitable sortable"
|-
!Date sort mode, sorting works for no preference and preference dmy
|-
|07 Apr 2007
|-
|<span style="display:none">00 Jan </span>2007
|-
|<span style="display:none">00</span> Mar 2007
|-
|16 Apr 2007
|-
|28 Feb 2007
|-
|[[28 Feb]] [[2007]]
|-
|28 Jan 2007
|-
|[[28 Jan]] [[2007]]
|-
|[[07 Apr]] [[2007]]
|-
|[[16 Apr]] [[2007]]
|-
|[[1 Mar]] [[2007]]
|-
|[[01 Mar]] [[2007]]
|-
|[[27 Mar]] [[2007]]
|-
|[[20 Aug]] [[2006]]
|-
|[[22 Jul]] [[2006]]
|-
|1 Mar 2007
|-
|01 Mar 2007
|-
|27 Mar 2007
|-
|20 Aug 2006
|-
|22 Jul 2006
|}
|}
{|
|'''String sort mode''' ''([{{fullurl:{{FULLPAGENAME}}|action=edit&section=15}} edit] to view source)''
{|class="wikitable sortable"
!date
|-
| [[2006]] <span style="display:none">a</span>
|-
| {{dts1|2006-12-03}}
|-
| {{dts1|-0000-03-27}}
|-
| <span style="display:none">2006-12 </span>[[December]] [[2006]]
|-
| <span style="display:none">!9936-04 </span>[[April]] [[64 BC]]
|-
| <span style="display:none">!9900-07-13</span>[[-0099-07-13]]
|-
| <span style="display:none">!9937-09-23</span>[[-0062-09-23]]
|-
| <span style="display:none">!9937-10-08</span>[[-0062-10-08]]
|-
| <span style="display:none">!9998-12-21</span>[[-0001-12-21]]
|-
| {{dts1|2006-11-08}}
|-
| {{dts1|0304-12-31}}
|-
| {{dts1|2005-05-15}}
|}
|}
The sort mode is based on the ''rendered'' format; in the case of links: the labels, not the targets (though including any content hidden by "display:none").

===Date sort mode===

One of the formats allowed for the date sort mode is produced by the [[Help:Date formatting and linking|Mediawiki's date-formatting feature]] in the right combination of preference and wikitext format: we need to use in the wikitext the format <nowiki>[[dd mmm]] [[yyyy]]</nowiki> (done in the example) and either no preference or preference dmy, or use with preference dmy one of the formats <nowiki>[[mmm dd]][[yyyy]], [[yyyy]][[mmm dd]], or [[yyyy]][[dd mmm]]</nowiki>.

Incomplete dates:
*<nowiki><span style="display:none">00 Jan </span>2007</nowiki>
*<nowiki><span style="display:none">00</span> Mar 2007</nowiki>

See also: [[bugzilla:8226]].

===String sort mode===

String sort mode provides chronological sorting for dates formated as <nowiki><span style="display:none">&</span></nowiki>YYYY-MM-DD; the hidden "&" avoids numeric sort mode.

Also we can hide the YYYY-MM-DD and put after that any choice of displayable text, including Mediawiki date formatting. The Wikipedia template {{tiw|dts}} provides a convenient way of applying this method while using the date-formatting feature for display.

For years BC we can use, for example, <code>!9937-09-23</code> for [[-0062-09-23]] (subtract the year number BC from 10000, or the absolute value of the astronomical year from 9999).
For years BC we can use, for example, <code>!9937-09-23</code> for [[-0062-09-23]] (subtract the year number BC from 10000, or the absolute value of the astronomical year from 9999).


If a table column contains any or all incomplete dates, this will not cause sorting problems. If only a year and month are given, that incomplete date is positioned alphabetically before the first day of the month in question. Likewise, if only a year is given, the date is positioned before the first month or day given for that year.
If a table column contains any or all incomplete dates, this will not cause sorting problems. If only a year and month are given, that incomplete date is positioned alphabetically before the first day of the month in question. Likewise, if only a year is given, the date is positioned before the first month or day given for that year.


===Use of #time===
If at some point (i.e., after possible previous sorting) the form <code><nowiki>[[YYYY]]</nowiki></code> is at the top with a non-negative year, sorting would be numerical; in this case, after toggling between ascending and descending there would be no proper sorting ''within'' each year (because [http://www.devguru.com/technologies/ecmascript/QuickRef/parsefloat.html parsefloat] is applied, finding the first number in the string, and basing sorting on only that number). Also, years BC would not be sorted properly. Therefore, alphabetic sorting has to be enforced. This can be done by putting a non-displayed character after the year, separated by a space.

====Use of #time====
Using parser function #time we can put <code><nowiki><span style="display:none">&{{#expr:3e11+{{#time:U|..}}}}</span></nowiki></code> in front of the displayed date. This works in the range 1 Jan 111, 00:00:00 through 31 Dec 9999, 23:59:59 for the [[w:Proleptic Gregorian calendar|proleptic Gregorian calendar]]. The added value makes all values positive and the same length (if scientific format would show up an additional step is needed to prevent this). The "&" forces string sort mode.
Using parser function #time we can put <code><nowiki><span style="display:none">&{{#expr:3e11+{{#time:U|..}}}}</span></nowiki></code> in front of the displayed date. This works in the range 1 Jan 111, 00:00:00 through 31 Dec 9999, 23:59:59 for the [[w:Proleptic Gregorian calendar|proleptic Gregorian calendar]]. The added value makes all values positive and the same length (if scientific format would show up an additional step is needed to prevent this). The "&" forces string sort mode.


Line 1,021: Line 586:


==Secondary sortkey==
==Secondary sortkey==
If a column contains a value multiple times then sorting the column preserves the order of the rows within each subset that has the same value in that column ({{mlw|Sorting_algorithm|Stability|stable sorting}}). Thus sorting based on a primary, secondary, tertiary, etc. sortkey can be done by sorting the least-significant sortkey first, etc.
The sorting algorithm employed is a {{mlw|Sorting_algorithm|Stability|stable sort}}: If a column contains a value multiple times then sorting the column preserves the order of the rows within each subset that has the same value in that column ({{mlw|Sorting_algorithm|Stability|stable sorting}}). Thus sorting based on a primary, secondary, tertiary, etc. sortkey can be done by sorting the least-significant sortkey first, etc.


'''First click on column Text and then on Numbers, you'll see that the ordering is on Numbers (1), Alphabet (2).'''
'''First click on column Text and then, while holding the shift-key, on Numbers, you'll see that the ordering is on Numbers (1), Alphabet (2).'''


{|class="wikitable sortable"
{|class="wikitable sortable"
Line 1,049: Line 614:
|-
|-
|3||z||01.sep.2006||1.50||row 11
|3||z||01.sep.2006||1.50||row 11
|-
|-class="sortbottom"
!Bottom!!!!!!!!
!Bottom!!!!!!!!
|-
|-
|}
|}


==Cell spanning multiple rows/cells==
==Keeping some rows together==
Cells which are spanning more than one row are treated as if it were multiple cells with the same value.
Partly hidden sortkeys can be used to keep certain rows together. The original mutual order of these rows is preserved.

Example where this is the case for the rows about the Netherlands:


'''Example:'''
{|class="wikitable sortable"
{|class="wikitable sortable"
! data-sort-type="date" | Date!!Name!!Height
!Country/province!!Capital
|-
|-
|01.10.1977||Smith||rowspan=2|1.85
|France||Paris
|-
|-
|11.6.1972||Adams
|Netherlands<span style="display:none">South Holland</span>||Amsterdam<span style="display:none">The Hague</span>
|-
|-
|1.9.1992||Bianchi||1.72
|<span style="display:none">Netherlands</span>South Holland||<span style="display:none">Amsterdam</span>The Hague
|-
|U.K.||London
|}
|}



==Limitations==
Javascript sorting may not work properly on tables with cells extending over multiple rows and/or columns (however, sorting of columns up to and including the first with ''colspan'' does not seem to be affected). Also, while cells can be empty, they should not be ''missing'' at the end of a row. In these cases sometimes the table gets messed up when attempting to sort, while other times some of the sorting buttons work while others don't.
Javascript sorting may not work properly on tables with cells extending over multiple rows and/or columns (however, sorting of columns up to and including the first with ''colspan'' does not seem to be affected). Also, while cells can be empty, they should not be ''missing'' at the end of a row. In these cases sometimes the table gets messed up when attempting to sort, while other times some of the sorting buttons work while others don't.


Line 1,125: Line 687:
*In '''alphabetic''' sorting, any footnotes etc. do not require a separate column; they can simply be put at the end of the element.
*In '''alphabetic''' sorting, any footnotes etc. do not require a separate column; they can simply be put at the end of the element.


Text undesired for display but needed for sorting:
*can be put as [[#Sorting with hidden sortkey|hidden text]] in the column to be sorted

Combining the two, we can have displayed text independent of text used for sorting, by fully hiding the latter, and fully putting the former in a separate column (in date sorting mode and numeric sorting mode) or in the same column after the hidden text (in alphabetic sorting). Fully putting the displayed text in a separate column may look ugly if it is not done consistently for a whole column, but only for elements that require this (e.g. if most entries in a column are single numbers, but some are ranges).


==Static column==
==Static column==
Line 1,307: Line 865:
In addition, no normalization of the Unicode text is being performed (so canonically equivalent strings, that should compare equal or with only very minor binary difference, may sometimes compare very far away, with completely different strings interleaved between them). For this reason, MediaWiki pages should always be encoded with their text in the Normalized Form C (preComposed), as recommended in the HTML standards.
In addition, no normalization of the Unicode text is being performed (so canonically equivalent strings, that should compare equal or with only very minor binary difference, may sometimes compare very far away, with completely different strings interleaved between them). For this reason, MediaWiki pages should always be encoded with their text in the Normalized Form C (preComposed), as recommended in the HTML standards.


As of today, an UCA-based sort is still not implemented in the client-side Javascript code (that's why you still need hidden sort keys), but some wikis are implementing a limited form of multilevel collation using custom basic replacement rules tuned for specific languages.
As of today, an UCA-based sort is still not implemented in the client-side Javascript code, but some wikis are implementing a limited form of multilevel collation using custom basic replacement rules tuned for specific languages.


==Server issue==
==Server issue==
It has been observed that the MediaWiki code on the server replaces a regular space before "!" by a [[w:non-breaking space|non-breaking space]] <code>&amp;#160;</code>, affecting the sorting order. To avoid this, this blank space can be coded as <code>&amp;#32;</code>, or the exclamation mark may be surrounded by <code>&lt;nowiki&gt;</code> and <code>&lt;/nowiki&gt;</code> tags. This is to comply with French typographic rules, where exclamation marks (and a few other punctuations) must be preceded (or sometimes followed) by a space (preferably narrow) which must still be unbreakable when it is effectively needed and present, the substitution being performed as an convenient editing facility of the Wiki code for cases that are very frequent within many texts.
It has been observed that the MediaWiki code on the server replaces a regular space before "!" by a [[w:non-breaking space|non-breaking space]] <code>&amp;#160;</code>, affecting the sorting order. To avoid this, this blank space can be coded as <code>&amp;#32;</code>, or the exclamation mark may be surrounded by <code>&lt;nowiki&gt;</code> and <code>&lt;/nowiki&gt;</code> tags. This is to comply with French typographic rules, where exclamation marks (and a few other punctuations) must be preceded (or sometimes followed) by a space (preferably narrow) which must still be unbreakable when it is effectively needed and present, the substitution being performed as an convenient editing facility of the Wiki code for cases that are very frequent within many texts.

==Browser issues==
With older versions of [[w:Safari (web browser)|Safari]] a table can only be sorted by the first column: all sort buttons have the effect that only the leftmost one is supposed to have.


==See also==
==See also==

Revision as of 21:00, 30 June 2011

Tables can be made sortable via client-side JavaScript with class="sortable" (in combination with the usual formatting: class="wikitable sortable"). This works in MediaWiki 1.9 and above, which is installed in all Wikimedia projects.

A sortable table is identified by the arrows in each of its header cells. Clicking them will cause the table rows to sort based on the selected column, in ascending order first, and subsequently toggling between ascending and descending order. Links and other wiki-markup are not possible in headers.

JavaScript

The JavaScript code jquery.tablesorter.js (source) of the tablesorter is loaded by the ResourceLoader. Some sites may have a page MediaWiki:Common.js which adds and overrides some code.

Sort modes

The way items are sorted depends on the data type of the item currently in the first row. To determine the data type, multiple cells are tested and the most appropriate format is chosen. Mismatches are possible, but can be easily corrected by manually specifying data-sort-type inside the header of the respective row:

{|class="wikitable sortable"
! data-sort-type="date" | Date!!Name!!Height
|-
|01.10.1977||Smith||1.85
|-
|11.6.1972||Ray||1.89
|-
|1.9.1992||Bianchi||1.72
|}

The following (case-insensitive) values are valid for data-sort-type:

  • text
  • number
  • IPAdress
  • currency
  • url
  • isoDate
  • usLongDate
  • date
  • time

Tags such as span or sup are ignored when determining data type.

Dates

Various date formats are supported, including those with localized month names. On the German Wikipedia, "16. März 2010" is correctly sorted as 2010-05-16

Most other numerical formats are supported as well, including those with different separators (such as . , ' or / ); On English Wikipedias dates are treated as US-Dates (eg. month-day-year) per default.

Numbers

The script can recognize numbers with different decimal separators (. and ,) as well as e/E numbers.


Text

Text is sorted in ASCII order (Any accented/special characters follow after the basic latin alphabet). This can be changed site wide by posting code like the following inside the common.js:

mw.config.set('tableSorterCollation', {'ä':'ae', 'ö' : 'oe', 'ß': 'ss', 'ü':'ue'});

Afterwards, all 'ä' will be sorted as if they were an ae etc. Partial list showing the default order: !"#$%&'()*+,-./09:;<=>?@[\]^_'az{|}~é—

Examples

numbers
 
-
4.0
15
10
1 2
1 aa
1 a b
1 aa
1 11
1 1 a
1 1
1
192
123,456.789
123,456,789
2,500,000,000
300,000,000
3,000,000 abc
5,000,000
2,000 def
-4,000
aaa
-9,999
4,000
9,999
800,000
900,000
numbers
123 564,589.7e12
9
-80
80 abc 5
abc 80
70
600
first alphabetic, later also numeric mode
123.4 ghi
2,500,000,000
300,000,000
3,000,000 abc
5,000,000
2,000 def
4,000
9,999
800,000
900,000
currencies
$ 9
$ 80
$ 70
$ 600
currencies
€ 9
€ 80
€ 70
€ 600
currencies
£ 9
£ 80
£ 70
£ 600
currencies
¥ 9
¥ 80
¥ 70
¥ 600
comparison
a 9
a 80
a 70
a 600
comparison
e 9
e 80
e 70
e 600

The example with "a" gives alphabetic sorting; that with "e" ditto, the data are not mistaken for numbers in scientific format.

mixed notations
1.4285714285714E+17
1000000000000000000
-1000000000000000000
.0000000000000000001
-.0000000000000000001
-1.4285714285714E+17
1.4285714285714E-13
-1.4285714285714E-13
89 123 456 788
89,123,456,789
333
1e10
e 9
e 80
e 70
e 600
999e9
88e80
7e270
999e-9
88e-80
7e-270
-999e9
−999e9
-88e80
-7e270
-999e-9
-88e-80
-7e-270
e3
-e3
1e3
e9
e80
e270
6e11
8e11
first number in each element counts
7-4
2
4
22/7
111
percentage
7%
2
4
22
111
mixed notations
14
-14
11
-12 (retrograde)
12 or 13
12 (?)
ca. 12
12 (approx.)
?

The first example demonstrates that text is positioned at zero, and that e.g. e3 for 1000 is not allowed; use 1e3 instead. It also shows that "-" should be used, not "−".

The second example shows that expressions are not sorted according to their evaluated value, but according to the first number.

The third example shows that a percentage is accepted for numeric sorting mode, but ignored in the actual sorting, so if a column contains percentages, all numbers have to be written as a percentage.

The fourth example shows again that "ca. 12" sorts at 0, as opposed to 12 with some text after it, which sorts at 12. In case such an element arrives at the top of a column, it causes alphabetic sorting mode.

Additional features

Excluding the last row from sorting

Sometimes it is helpful to exclude the last row of a table from the sorting process.

This can be achieved by declaring the last row as a footer

Wiki markup

{|class="wikitable sortable"
!Name!!Surname!!Height
|-
|John||Smith||1.85
|-
|Ron||Ray||1.89
|-
|Mario||Bianchi||1.72
|-
! !!Average:||1.82
|}

What it looks like in your browser

Name Surname Height
John Smith 1.85
Ron Ray 1.89
Mario Bianchi 1.72
Average: 1.82

Excluding the first row from sorting

The same can be applied for first rows as well, by declaring them as header using the same exclamation mark notation.

Making a column unsortable

If you want a specific column not to be sortable, specify class="unsortable" in the attributes of its header cell.

Wiki markup

{|class="wikitable sortable"
!Numbers!!Alphabet!!Dates!!Currency!!class="unsortable"|Unsortable
|-
|1||Z||02-02-2004||5.00||This
|-
|2||y||13-apr-2005||||Column
|-
|3||X||17.aug.2006||6.50||Is
|-
|4||w||01.Jan.2005||4.20||Unsortable
|-
|5||V||05/12/2006||7.15||See?
|-
!Total: 15!!!!!!Total: 29.55!!
|-
|}

What it looks like in your browser

Numbers Alphabet Dates Currency Unsortable
1 Z 02-02-2004 5.00 This
2 y 13-apr-2005 Column
3 X 17.aug.2006 6.50 Is
4 w 01.Jan.2005 4.20 Unsortable
5 V 05/12/2006 7.15 See?
Total: 15 Total: 29.55 Original example

Correcting a wrongly parsed cell

Sometimes the value of a cell is not correctly parsed or one wants to sort the row in a special way. (e.g. a cell containing 'John Doe' should actually be sorted as 'Doe' and not as 'John')

This can be easily achieved by manually setting

data-sort-value

Wiki markup

{|class="wikitable sortable"
!Name and Surname!!Height
|-
|data-sort-value="Smith"|John Smith||1.85
|-
|data-sort-value="Ray"|Ian Ray||1.89
|-
|data-sort-value="Bianchi"|Zachary Bianchi||1.72
|-
!Average:||1.82
|}

What it looks like in your browser

Name and Surname Height
John Smith 1.85
Ian Ray 1.89
Zachary Bianchi 1.72
Average: 1.82

Keeping some rows together

data-sort-value can be used to keep certain rows together. The original mutual order of these rows is preserved.

Example where this is the case for the rows about the Netherlands:

Country/province Capital
France Paris
Netherlands Amsterdam
South Holland The Hague
U.K. London

Special dates

For years BC we can use, for example, !9937-09-23 for -0062-09-23 (subtract the year number BC from 10000, or the absolute value of the astronomical year from 9999).

If a table column contains any or all incomplete dates, this will not cause sorting problems. If only a year and month are given, that incomplete date is positioned alphabetically before the first day of the month in question. Likewise, if only a year is given, the date is positioned before the first month or day given for that year.

Use of #time

Using parser function #time we can put <span style="display:none">&{{#expr:3e11+{{#time:U|..}}}}</span> in front of the displayed date. This works in the range 1 Jan 111, 00:00:00 through 31 Dec 9999, 23:59:59 for the proleptic Gregorian calendar. The added value makes all values positive and the same length (if scientific format would show up an additional step is needed to prevent this). The "&" forces string sort mode.

Dates and times can be entered in any php date/time format. Note that when we have just a year, a month (typically Jan) must be added in the hidden part.

Example using Help:Sorting/date:

input date text date and time as interpreted, with hidden sortkey input with visible sortkey input with hidden sortkey Unix time

To use dates before the year 111, add a multiple of 400, e.g. 6000, to all years, this effectively shifts the range to 1 Jan -5889, 00:00:00 through 31 Dec 3999, 23:59:59, without changing the calendar.

See also:

Secondary sortkey

The sorting algorithm employed is a stable sort: If a column contains a value multiple times then sorting the column preserves the order of the rows within each subset that has the same value in that column (stable sorting). Thus sorting based on a primary, secondary, tertiary, etc. sortkey can be done by sorting the least-significant sortkey first, etc.

First click on column Text and then, while holding the shift-key, on Numbers, you'll see that the ordering is on Numbers (1), Alphabet (2).

Numbers Text Dates Currency More text
4 a 01.Jan.2005 4.20 row 1
5 a 05/12/2006 7.15 row 2
1 b 02-02-2004 5.00 row 3
1 a 02-02-2004 5.00 row 4
2 x 13-apr-2005 row 5
2 a 13-apr-2005 row 6
3 a 17.aug.2006 6.50 row 7
3 z 25.aug.2006 2.30 row 8
3 z 28.aug.2006 5.50 row 9
3 z 31.aug.2006 3.77 row 10
3 z 01.sep.2006 1.50 row 11
Bottom

Cell spanning multiple rows/cells

Cells which are spanning more than one row are treated as if it were multiple cells with the same value.

Example:

Date Name Height
01.10.1977 Smith 1.85
11.6.1972 Adams
1.9.1992 Bianchi 1.72


Javascript sorting may not work properly on tables with cells extending over multiple rows and/or columns (however, sorting of columns up to and including the first with colspan does not seem to be affected). Also, while cells can be empty, they should not be missing at the end of a row. In these cases sometimes the table gets messed up when attempting to sort, while other times some of the sorting buttons work while others don't.

Colspan workaround

To allow sorting, the formal number of cells in each row should be equal (if not all columns are made sortable this should apply at least for the number of cells up to and including the last sortable column). However, with a CSS hack the number of cells shown in a row can differ from the formal number of cells. For example, two formal cells can be shown as one by specifying a width for the first column, shifting the contents of the second cell to the left, increasing its width by the same amount, and hiding the cell border that would normally be visible. Hidden sortkeys can be used to control, for sorting with respect to each column, how this row should be sorted.

Example:

Country Capital
France Paris
Z M
Sorting with respect to the first column this row sorts like Z, with respect to the second column like M
U.K. London

This can be combined with the method of "keeping some rows together" demonstrated above. For an example of an application of this, consider a table of three columns where the third column would make the table too wide, such as a column of miscellaneous details. These details can be put in separate rows, each staying below the corresponding row when the table is sorted.

Example:

Country Capital
France Paris
In Paris is the Eiffel Tower.
France Paris
In Paris is the Eiffel Tower.
U.K. London
In the U.K. you cannot pay with euros.
U.K. London
In the U.K. you cannot pay with euros.
Germany Berlin
Germany includes the former DDR.
Germany Berlin
Germany includes the former DDR.

A table row template makes this technique less cumbersome to apply, see e.g. w:List of furry conventions, w:Template:Furry-con-list-start and w:Template:Furry-con-list-entry.

Controlling sorting and display

Text undesired for sorting but needed for display:

  • In numeric sorting mode, the sorting will still work properly even though the cell (except the cell of the first data row) contains text after numbers (e.g. "200 approx"). Empty cell is treated as "zero" when sorting numerically. See e.g. Help:Sorting/countries. However bear in mind that the cell of the first data row will change accordingly after sorting. If that cell no longer contains number only after sorting, the sorting mode will change. For example, if the cell of the first data row becomes "200 approx" after sorting, this will make the sorting mode alphabetic.
  • In date sorting mode, this text needs to be put in a separate column; in the case of a cell containing a range of dates or numbers (e.g. from .. to ..), text in surplus of what is required for sorting is put in the extra column. If the first part of the text is used for sorting, then the extra column needs to be the following one; conversely, if the last part of the text is used for sorting, then the extra column needs to be the previous one; depending on the table format, this dividing of an item over two cells may look ugly.
  • In alphabetic sorting, any footnotes etc. do not require a separate column; they can simply be put at the end of the element.


Static column

A static column, e.g. with row numbers, can be obtained with two side-by-side tables with for each row the same height set in both tables:

Number
1
2
Country Capital
The Netherlands Amsterdam (although The Hague is the seat of government)
France Paris

The style can be adjusted to make it appear as a single table. If for some row the height of that row is too small for the text in a cell on one of the sides, the browser increases it, and there is no longer a match.

Default order

It is not possible to make a table appear sorted by a certain column without the user clicking on it. By default, the rows of a table always appear in the same order as in the wikitext. If you want a table to appear sorted by a certain column, you must sort the wikitext itself in that order; see the next section for one way to do this.

Sorting the wikitext of a table

Sorting the wikitext itself, thus creating a new default sort order, can be done semi-automatically by making an auxiliary sortable table where each row is rendered as the wikitext for the corresponding row of the original table. Applying the JavaScript sorting as desired, the result can be copied to provide the sorted wikitext for the original table.

Example:

Original table:

demo
9
12
11

Auxiliary table:

aux
|-
| 9
|-
|12
|-
|11

After copying the rendered text to the edit box, to provide the body of the table syntax (between the header part and the closing line), this renders as a new table, sorted by default:

demo
9
11
12

The auxiliary table can be kept, to be reused in case one later (or on another page) wants to use another column for determining the default order, or wants to change between ascending and descending.

Basic alphabetic sorting order

demo
!
"
#
$
%
&
'
(
)
*
+
,
-
.
/
0
9
:
;
<
=
>
?
@
[
\
]
^
_
`
A
Z
a
z
A1
Z1
a1
z1
{
|
}
~
É
é
É1
é1

The two-character entries such as A1 demonstrate that A and a are at the same position.

This is not a fully alphabetic sort order: letter case is first folded to lowercase using a basic 1-to-1 conversion table (limited to the Basic Multilingual Plane of Unicode, and whose coverage and completeness still depends on browser versions and on their current implementation of the versioned Unicode Character Database), but letters with diacritics (and all other digits, symbols or special whitespaces or format control characters) will still sort according to the binary encoding of the casefolded letter, using the binary order of the UTF-16 code units (exposed and seen in Javascript through the parsed HTML DOM), but not the binary order of UTF-8 code units in the HTML page, and not of codepoints as one could also expect for encoded characters in supplementary planes).

In addition, no normalization of the Unicode text is being performed (so canonically equivalent strings, that should compare equal or with only very minor binary difference, may sometimes compare very far away, with completely different strings interleaved between them). For this reason, MediaWiki pages should always be encoded with their text in the Normalized Form C (preComposed), as recommended in the HTML standards.

As of today, an UCA-based sort is still not implemented in the client-side Javascript code, but some wikis are implementing a limited form of multilevel collation using custom basic replacement rules tuned for specific languages.

Server issue

It has been observed that the MediaWiki code on the server replaces a regular space before "!" by a non-breaking space &#160;, affecting the sorting order. To avoid this, this blank space can be coded as &#32;, or the exclamation mark may be surrounded by <nowiki> and </nowiki> tags. This is to comply with French typographic rules, where exclamation marks (and a few other punctuations) must be preceded (or sometimes followed) by a space (preferably narrow) which must still be unbreakable when it is effectively needed and present, the substitution being performed as an convenient editing facility of the Wiki code for cases that are very frequent within many texts.

See also

Examples elsewhere:


Links to other help pages

Help contents
Meta · Wikinews · Wikipedia · Wikiquote · Wiktionary · Commons: · Wikidata · MediaWiki · Wikibooks · Wikisource · MediaWiki: Manual · Google
Versions of this help page (for other languages see further)
What links here on Meta or from Meta · Wikipedia · MediaWiki
Reading
Go · Search · Namespace · Page name · Section · Backlinks · Redirect · Category · Image page · Special pages · Printable version
Tracking changes
Recent changes (enhanced) | Related changes · Watching pages · Diff · Page history · Edit summary · User contributions · Minor edit · Patrolled edit
Logging in and preferences
Logging in · Preferences
Editing
Starting a new page · Advanced editing · Editing FAQ · Export · Import · Shortcuts · Edit conflict · Page size
Referencing
Links · URL · Interwiki linking · Footnotes
Style and formatting
Wikitext examples · CSS · Reference card · HTML in wikitext · Formula · Lists · Table · Sorting · Colors · Images and file uploads
Fixing mistakes
Show preview · Reverting edits
Advanced functioning
Expansion · Template · Advanced templates · Parser function · Parameter default · Magic words · System message · Substitution · Array · Calculation · Transclusion
Others
Special characters · Renaming (moving) a page · Preparing a page for translation · Talk page · Signatures · Sandbox · Legal issues for editors
Other languages: