If true, the cache will contain duplicated cell contents for every column the colspan includes. This makes it easier to sort & filter columns because a cell spanning all columns will only work with one parser.

In v2.25.8, the contents of cells that are spanned will be set to an empty string only if the textExtraction setting is left as a string. If a function is added, it will be used to attempt to extract other content from the spanned cell (see Stackoverflow for an example).

// this row: <tr><td colspan="3">foo</td><td>bar</td></tr> results in this row cache:
[ 'foo', 'foo', 'foo', 'bar' ] // if duplicateSpan = true
[ 'foo', '',    '',    'bar' ] // if duplicateSpan = false (no textExtraction function)

*NOTE*

• Cells in the tbody with a rowspan are not yet supported and will not sort or filter as you would expect.
• Having these values in the cache does not automatically guarantee that all widgets will work as expected with colspans in the tbody (e.g. scroller widget with fixed columns)

Changed to empty string ("") in v2.11, as the "tablesorter-headerAsc" class will always be added to a header cell with an ascending sort; this option now contains any additional class names to add.

Example from the blue theme:

.tablesorter-blue .tablesorter-headerAsc {
  background-color: #9fbfdf;
  background-image: url(black-asc.gif);
}

Default changed v2.5 to "tablesorter-headerAsc". Default changed v2.1.7 to "tablesorter-headerSortUp". Original default: "headerSortUp"

Changed to empty string in v2.11, as the "tablesorter-headerDesc" class will always be added to a header cell with a descending sort; this option now contains any additional class names to add.

Example from the blue theme:

.tablesorter-blue .tablesorter-headerDesc {
  background-color: #8cb3d9;
  background-image: url(black-desc.gif);
}

Default changed v2.5 to "tablesorter-headerDesc". Default changed v2.1.7 to "tablesorter-headerSortDown". Original default: "headerSortDown"

Changed to empty string in v2.11, as the "tablesorter-header" class will always be added to the table headers; this option now contains any additional class names to add.

Example from the blue theme:

.tablesorter-blue .tablesorter-header {
  background-color: #99bfe6;
  background-repeat: no-repeat;
  background-position: center right;
  padding: 4px 20px 4px 4px;
  white-space: normal;
  cursor: pointer;
}

Default changed v2.1.7 to "tablesorter-header". Original default: "header"

Changed to empty string in v2.11, as the "tablesorter-headerRow" class will always be added to a table header row; this option now contains any additional class names to add.

This CSS style was added in v2.4, prior to that the row would get the same class as the header cells. This class was added to make it easier to determine what element was being targeted in the plugin.

In v2.21.1, adding multiple class names to this option is now properly supported.

As of v2.7, the icon will only be added to the header if both the cssIcon option is set AND the headerTemplate option includes the icon tag ({icon}).

In v2.4, an <i> element, with this class name, is automatically appended to the header cells. To prevent the plugin from adding an <i> element to the headers, set the cssIcon option to an empty string.

This class is only applied when the headerTemplate option includes a {icon} tag or an HTML element with the class name from the cssIcon option.

This class is only applied when the headerTemplate option includes a {icon} tag or an HTML element with the class name from the cssIcon option.

This class is only applied when the headerTemplate option includes a {icon} tag or an HTML element with the class name from the cssIcon option.

A "tablesorter-headerUnSorted" class will always be added to an unsorted header cell; this option contains any additional class names to add. Currently, no themes use this class name.

Changed to empty string in v2.11, as the "tablesorter-processing" class will always be added to a table cells during processing; this option now contains any additional class names to add.

This class name is added to the header cell that is currently being sorted or filted. To prevent this class name from being added, set the showProcessing option to false.

With the addition of multiple tbody sorting in v2.2, you can now insert a non-sorting tbody within the table by adding this class to the tbody.

<tbody class="tablesorter-infoOnly">
  <tr>
    <th>The contents of this tbody</th>
  </tr>
  <tr>
    <td>will not be sorted</td>
  </tr>
</tbody>

As an example, I've split up this options table into three (3) tbodies. The first contains the active options, the second is the info block with a row that only contains the text "Deprecated Options", and the last tbody contains the deprecated options. Sort the table to see how each tbody sorts separately.

NOTE! The pager plugin will only be applied to the first tbody, as always. I may work on modifying this behavior in the future, if I can figure out the best implementation.

Header rows with this class name will not be added into the table.config.$headers variable.

This class name should be added to header rows that contain custom HTML, like for the pager controls, custom filter row or table toolbar.

• "mmddyyyy" (default)
• "ddmmyyyy"
• "yyyymmdd"

In previous versions, this option was set as "us", "uk" or "dd/mm/yy". This option was modified to better fit needed date formats. It will only work with four digit years!

The sorter should be set to "shortDate" and the date format can be set in the "dateFormat" option or set for a specific columns within the "headers" option. See the demo page to see it working.

$(function(){
  $("table").tablesorter({

    dateFormat : "mmddyyyy", // default date format

    // or to change the format for specific columns,
    // add the dateFormat to the headers option:
    headers: {
      0: { sorter: "shortDate" }, // "shortDate" with the default dateFormat above
      1: { sorter: "shortDate", dateFormat: "ddmmyyyy" }, // day first format
      2: { sorter: "shortDate", dateFormat: "yyyymmdd" }  // year first format
    }

  });
});

Individual columns can be modified by adding the following (they all do the same thing), set in order of priority (Modified v2.3.1):

• jQuery data data-dateFormat="mmddyyyy".
• metadata class="{ dateFormat: 'mmddyyyy'}". This requires the metadata plugin.
• headers option headers : { 0 : { dateFormat : 'mmddyyyy' } }.
• header class name class="dateFormat-mmddyyyy".
• Overall dateFormat option.

• bottom - sort empty table cells to the bottom.
• top - sort empty table cells to the top.
• none or zero - sort empty table cells as if the cell has the value equal to zero.
• emptyMax - sort empty table cells as having a value greater than the max (more positive) value (v2.16.2).
• emptyMin - sort empty table cells as having a value greater than the min (more negative) value (v2.16.2).

Individual columns can be modified by adding the following (they all do the same thing), set in order of priority:

• jQuery data data-empty="top".
• metadata class="{ empty: 'top'}". This requires the metadata plugin.
• headers option headers : { 0 : { empty : 'top' } }.
• header class name class="empty-top".
• Overall emptyTo option.

emptyToBottom option was added in v2.1.11, then replaced by the emptyTo option in v2.1.16.

For example, to disable sorting on the first two columns of a table: headers: { 0: { sorter: false}, 1: {sorter: false} }.

The plugin attempts to detect the type of data that is contained in a column, but if it can't figure it out then it defaults to alphanumeric. You can easily override this by setting the header argument (or column parser). See the full list of default parsers here or write your own.

$(function(){
  $("table").tablesorter({
    headers: {

      // See example - Disable first header cell; parser false skips extracting content
      0: { sorter: false, parser: false },

      // See example 2: Sort column numerically & treat any text as if its value is:
      1: { sorter: "digit", empty:  "top" }, // zero; sort empty cells to the top
      2: { sorter: "digit", string: "max" }, // maximum positive value
      3: { sorter: "digit", string: "min" }, // maximum negative value

      // Sort the fifth column by date & set the format
      4: { sorter: "shortDate", dateFormat: "yyyymmdd" }, // year first format

      // See example 3: lock the sort order
      // this option will not work if added as metadata
      5: { lockedOrder: "asc" },

      // See Example 4: Initial sort order direction of seventh header cell
      6: { sortInitialOrder: "desc" },

      // Set filter widget options for this column
      // See the "Applying the filter widget" demo
      7: { filter: false },    // disable filter widget for this column
      8: { filter: "parsed" }, // use parsed data for this column in the filter search

      // Set resizable widget options for this column
      9: { resizable: false } // prevent resizing of header cell 9

    }
  });
});

Please note that the headers index values corresponds to the table header cells index (zero-based) and not the actual columns. For example, given the following table thead markup, the header-index counts the header th cells and does not actually match the data-column index when extra rows and/or colspan or rowspan are included in any of the header cells:

<thead>
	<tr>
		<th colspan="4" data-column="0">header-index 0</th>
	</tr>
	<tr>
		<th data-column="0">header-index 1</th>
		<th data-column="1">header-index 2</th>
		<th data-column="2">header-index 3</th>
		<th data-column="3">header-index 4</th>
	</tr>
	<tr>
		<th colspan="2" data-column="0">header-index 5</th>
		<th colspan="2" data-column="2">header-index 6</th>
	</tr>
</thead>

So, in the above example, to disable the sort of the second table column (data-column index of 1), the header cell of index 2 needs to be set as follows: 2 : { sorter : false }.

In v2.17.0, you can reference the column(s) using a class name, id or column index.

headers : {
    '.first-name' : { sorter: 'text' },
    '.disabled'   : { sorter: false }
}

Warning What won't work is if you try to target the header using a filtering selector that uses an index, e.g. "th:eq()", ":gt()", ":lt()", ":first", ":last", ":even" or ":odd", ":first-child", ":last-child", ":nth-child()", ":nth-last-child()", etc.

In v2.17.8, if this option is set to an empty string (''), an inner div will no longer be wrapped around the header content.

This template string has two modifying tags: {content} and {icon}.
{content} will be replaced by the current header HTML content.
{icon} will be replaced by <i class="tablesorter-icon"></i>, but only if a class name is defined in the cssIcon option.

This template string may also contain HTML, e.g ('<em>{content}</em> {icon}')

After the template string is built, the onRenderTemplate function is called to allow further manipulation. Please read more about this onRenderTemplate function and/or check out the example (link to the right).

$(function(){

  // bind to tablesorter-initialized event BEFORE initializing tablesorter*
  $("table")
    .bind("tablesorter-initialized",function(e, table) {
      // do something after tablesorter has initialized
    });

  // initialize the tablesorter plugin
  $("table").tablesorter({
    // this is equivalent to the above bind method
    initialized : function(table){
      // do something after tablesorter has initialized
    }
  });

});

* Note: bind to all initialization events before initializing tablesorter; because most of the time, if bound after, the events will fire before the binding occurs.

When true, all widgets set by the widgets option will apply after tablesorter has initialized, this is the normal behavior.

If false, the each widget set by the widgets option will be initialized, meaning the "init" function is run, but the format function will not be run. This is useful when running the pager plugin after the table is set up. The pager plugin will initialize, then apply all set widgets.

Why you ask? Well, lets say you have a table with 1000 rows that will have the pager plugin applied to it. Before this option, the table would finish its setup, all widgets would be applied to the 1000 rows, pager plugin initializes and reapplies the widgets on the say 20 rows showing; making the widget application to 100 rows unnecessary and a waste of time. So, when this option is false, widgets will only be applied to the table after the pager is set up.

By default, this option is set to 'widget-{name}'. So if the table has a class name of widget-zebra the zebra widget will be automatically added to the config.widgets option and applied to the table.

Some widget ID's with special characters may not be detected; ID's with letters, numbers, underscores and/or dashes will be correctly detected.

The template string *must* contain the {name} tag.

In versions 2.0.6+, all TH text is wrapped in a div with a class name of "tablesorter-inner" by default. In the example below, the header cell (TH) div is given a class name (source).
Function parameters:

• index - zero-based index of the current table header cell; this value is not indicative of the column index, as it is simply a count of header cells. So it will be effected by rowspan, colspan and multiple rows in the header.
• config - The current table.config.
• $table - This value is the current table jQuery object. If this function is being applied to cloned headers, as is does in the stickyHeaders widget, then this value will contain the sticky header clone added after the current table, and not the main table (v2.18.0).

$(function(){
  $("table").tablesorter({
    headerTemplate: '{content}',
    onRenderHeader: function (index, config, $table){
      $(this).find('div').addClass('roundedCorners');
    }
  });
});

and you'll end up with this HTML (only the thead is shown)

<thead>
  <tr>
    <th class="tablesorter-header"><div class="tablesorter-header-inner roundedCorners">Column 1</div></th>
    <th class="tablesorter-header"><div class="tablesorter-header-inner roundedCorners">Column 2</div></th>
  </tr>
</thead>

* Note: this function adds additional rendering time to the table if any DOM manipulation is done. Because this time will be on top of the processing time already added by the template.

The onRenderTemplate function receives a column index and template string parameters. The template string, from the headerTemplate option, will already have the {icon} and {content} tags replaced; it's just a string of formatted HTML. When done manipulating this string, return it. Here is an example:

$(function(){
  $("table").tablesorter({
    headerTemplate: '{icon}{content}',
    onRenderTemplate: function (index, template){
      return '<em>' + (index + 1) + ':</em> ' + template;
    }
  });
});

The template parameter can be manipulated as a string, or if you prefer, turn it into a jQuery object (var $t = $(template)) to find and replace content as desired. Just make sure you return a string (return $t.html())

From the example function above, you'll end up with something similar to this HTML (only the thead is shown)

<thead>
  <tr>
    <th class="tablesorter-header"><div class="tablesorter-header-inner"><em>1:</em> <i class="tablesorter-icon"></i>First Name</div></th>
    <th class="tablesorter-header"><div class="tablesorter-header-inner"><em>2:</em> <i class="tablesorter-icon"></i>Last Name</div></th>
  </tr>
</thead>

* Note: If the cssIcon option is an empty string, the {icon} tag will also become an empty string.

You can change this, but the table will still need the required thead and tbody before this plugin will work properly.
Added > to the selector in v2.3 to prevent targeting nested table headers. It was modified again in v2.4 to include td cells within the thead.

It was necessary to add this option because some widgets add table rows for styling (see the writing custom widgets demo) and if a table update is triggered ($('table').trigger('update');) those added rows will automatically become incorporated into the table.

Specifically, this option applies to the "updateAll", "update", "addRows" and "updateCell" methods and is checked after the method has completed updating the internal cache.

If false, the widgets will still be refreshed for all but the "updateCell" method - this "updateCell" behavior was added in v2.19.0.

Note when triggering one of the above methods, and passing a defined resort parameter, it will override this setting.

Note if a sort is not reapplied, problems with some widgets may occur namely the grouping widget.

For example, sortForce: [[0,0]] will sort the first column in ascending order. After the forced sort, the user selected column(s), or during initialzation, the sorting order defined in the sortList will follow. And lastly, the sort defined in the sortAppend option will be applied. More explicitly:

There are three options to determine the sort order and this is the order of priority:

1. sortForce forces the user to have this/these column(s) sorted first (null by default).
2. SortList is the initial sort order of the columns.
3. SortAppend is the default sort that is added to the end of the users sort selection (null by default; v2.24.0).

The value of these sort options is an array of arrays and can include one or more columns. The format is an array of instructions for per-column sorting and direction in the format: [[columnIndex, sortDirection], ... ] where columnIndex is a zero-based index for your columns left-to-right and sortDirection is 0 for Ascending and 1 for Descending. A valid argument that sorts ascending first by column 1 and then column 2 looks like: [[0,0],[1,0]].

$(function(){
  $("table").tablesorter({
    sortForce  : [[0,0]],        // Always sort first column first
    sortList   : [[1,0], [2,0]], // initial sort columns (2nd and 3rd)
    sortAppend : [[3,0]]         // Always add this sort on the end (4th column)
  });
});

The value contains an array of instructions for per-column sorting and direction in the format: [[columnIndex, sortDirection], ... ] where columnIndex is a zero-based index for your columns left-to-right and sortDirection is 0 for Ascending and 1 for Descending. A valid argument that sorts ascending first by column 1 and then column 2 looks like: [[0,0],[1,0]]. Please see sortForce for more details on other sort order options.

$(function(){
  $("table").tablesorter({
    sortList : [[1,0], [2,0]] // initial sort columns (2nd and 3rd)
  });
});

This option can also be set using data-attributes (v2.3.1), jQuery data or metadata on the table:

** Note: data-sortlist data is not supported in jQuery versions older than 1.4.
jQuery data	<table data-sortlist="[[0,0],[4,0]]"> **
Meta data	<table class="tablesorter {sortlist: [[0,0],[4,0]]}">

For example, can be used to sort people alphabetically after some other user-selected sort that results in rows with the same value like dates or money due. It can help prevent data from appearing as though it has a random secondary sort.

$(function(){
  $("table").tablesorter({
    sortAppend : [[1,0], [2,0]] // always append sorting of 2nd and 3rd column
  });
});

The value contains an array of instructions for per-column sorting and direction in the format: [[columnIndex, sortDirection], ... ] where columnIndex is a zero-based index for your columns left-to-right and sortDirection is 0 for Ascending and 1 for Descending. A valid argument that sorts ascending first by column 1 and then column 2 looks like: [[0,0],[1,0]]. Please see sortForce for more details on other sort order options.

In v2.24.0, the sortAppend option now accepts an object containing column indexes.

Also, the sort direction can be set using "a" (ascending), "d" (descending), "n" (next), "s" (same) & "o" (opposite):

$(function(){
  $("table").tablesorter({
    sortAppend: {
      0 : [[ 1,'a' ]], // always apply ascending sort
      2 : [[ 3,'o' ]], // sort "o"pposite of column 2 direction
      4 : [[ 5,'s' ], [ 0,'s' ]]  // sort "s"ame as column 4 direction
    }
  });
});

This order can also be set by desired column using the headers option (v2.0.8).

Individual columns can be modified by adding the following (they all do the same thing), set in order of priority (modified v2.3.1):

• jQuery data data-sortInitialOrder="asc".
• metadata class="{ sortInitialOrder: 'asc'}". This requires the metadata plugin.
• headers option headers : { 0 : { sortInitialOrder : 'asc' } }.
• header class name class="sortInitialOrder-asc".
• Overall sortInitialOrder option.

• This option no longer switches the sort to use the String.localeCompare method.
• When this option is true, the text parsed from table cells will convert accented characters to their equivalent to allow the alphanumeric sort to properly sort.
• If false (default), any accented characters are treated as their value in the standard unicode order.
• The following characters are replaced for both upper and lower case (information obtained from sugar.js sorting equivalents table):
  • áàâãä replaced with a
  • ç replaced with c
  • éèêë replaced with e
  • íìİîï replaced with i
  • óòôõöō replaced with o
  • úùûü replaced with u
  • ß replaced with S
• Please see the example page for instrcutions on how to modify the above equivalency table.
• If you would like to continue using the String.localeCompare method, then set the sortLocaleCompare option to false and use the new textSorter option as follows:

  $('table').tablesorter({
    textSorter: function(a,b) {
      return a.localeCompare(b);
    }
  });

NOTE! See the Language wiki page for language specific examples and how to extend the character equivalent tables seen in the sortLocaleCompare demo.

Boolean flag indicating whenever to use javascript String.localeCompare method or not.
This is only used when comparing text with international character strings. A sort using localeCompare will sort accented characters the same as their unaccented counterparts.

Don't confuse this option with the sortReset method. This option only resets the column sort after a third click, while the method immediately resets the entire table sort.

This isn't exactly a stable sort because the sort order maintains the original unsorted order when sorting the column in an ascending direction. When sorting the column in a descending order, the opposite of the original unsorted order is returned. If that doesn't make any sense, please refer to issue #419.

String options was initially set in the header options only. Overall option added and values changed in version 2.1.16; setting the value to:

• "max" will treat any text in that column as a value greater than the max (more positive) value. Renamed from "max+".
• "min" will treat any text in that column as a value greater than the min (more negative) value. Renamed from "max-".
• "top" will always sort the text to the top of the column.
• "bottom" will always sort the text to the bottom of the column.
• "none" or "zero" will treat the text as if it has a value of zero.

Individual columns can be modified by adding the following (they all do the same thing), set in order of priority:

• jQuery data data-string="top".
• metadata class="{ string: 'top'}". This requires the metadata plugin.
• headers option headers : { 0 : { string : 'top' } }.
• header class name class="string-top".
• Overall stringTo option.

Changed to empty string in v2.11, as the "tablesorter" class will always be added to the table; this option now contains any additional class names to add.

This class was required in the default markup in version 2.0.5. But in version 2.0.6, it was added as an option.

Modify this option if you are not using the default css, or if you are using a completely custom stylesheet.

*NOTE* If creating a custom theme file, make sure to include a filter definition to hide filtered out rows:

.filtered { display: none; }

Note the .filtered class can be modified using the filter_filteredRow option.

When changing this theme option (the actual theme name is inside parentheses), make sure that the appropriate css theme file has also been loaded. Default theme files include: see all themes

---

uitheme widget

You will need to use the uitheme widget to extend the theme to apply css from jQuery UI, Bootstrap or other css libraries.

Modify a theme

If you want to modify the existing themes ("jui" and "bootstrap"), it can be done as follows:

Modify the class names by extending from the $.tablesorter.themes variable

Note there is no need to extend from the entire list of class names, just include the key:value pairs that are being changed:

// Extend a theme to modify any of the default class names
$.extend($.tablesorter.themes.jui, {
  // change default jQuery uitheme icons - find the full list of icons
  // here: http://jqueryui.com/themeroller/ (hover over them for their name)
  table      : 'ui-widget ui-widget-content ui-corner-all', // table classes
  header     : 'ui-widget-header ui-corner-all ui-state-default', // header classes
  footerRow  : '',
  footerCells: '',
  icons      : 'ui-icon', // icon class added to the <i> in the header
  sortNone   : 'ui-icon-carat-2-n-s',
  sortAsc    : 'ui-icon-carat-1-n',
  sortDesc   : 'ui-icon-carat-1-s',
  active     : 'ui-state-active', // applied when column is sorted
  hover      : 'ui-state-hover',  // hover class
  filterRow  : '',
  even       : 'ui-widget-content', // even row zebra striping
  odd        : 'ui-state-default'   // odd row zebra striping
});

Custom theme

To add a new uitheme, define it as follows (replace "custom" with the name of your theme):

$.tablesorter.themes.custom = {
  table      : 'table',       // table classes
  header     : 'header',      // header classes
  footerRow  : '',
  footerCells: '',
  icons      : 'icon',        // icon class added to the <i> in the header
  sortNone   : 'sort-none',   // unsorted header
  sortAsc    : 'sort-asc',    // ascending sorted header
  sortDesc   : 'sort-desc',   // descending sorted header
  active     : 'sort-active', // applied when column is sorted
  hover      : 'hover',       // hover class
  filterRow  : 'filters',     // class added to the filter row
  even       : 'even',        // even row zebra striping
  odd        : 'odd'          // odd row zebra striping
}

Then use it by adding the name of your theme to the theme option:

$(function(){
  $("table").tablesorter({
    // set the new theme name from $.tablesorter.themes here
    theme   : 'custom',
    // add {icon} to template (if needed)
    headerTemplate: '{content}{icon}',
    // make sure to initialize uitheme widget
    widgets : ["uitheme"]
  });
});

This option contains the name of the data-attribute used by the textExtraction function. Add it to the cell(s) as follows:

<td data-text="1">First repository</td>

Note This option only works when the textExtraction option is set to "basic".

*NOTE* It is important to know that the filter widget is set to use extracted (parsed) content as a parsed value and the raw cell content as unparsed values; and most of the time the filter widget is searching unparsed content. But, when a data-attribute is used, both the parsed and raw cached data will contain the exact same content (ref)!

* Note This option accepts multiple types (String, Object or Function); see below for further details.

In v2.19.0, the code was further optimized. When set to "basic" (the default), the textExtraction code will check for data-attributes, otherwise, any other string value setting will skip the data-attribute value check; because of this change, there is a noticable lessening of initialization time in Internet Explorer.

In v2.17.0, the textExtraction column can also be referenced by using a jQuery selector (e.g. class name, id or column index) that points to a table header cell.

textExtraction : {
    // 'jQuery thead cell selector' : function ( new method )
    '.styled' : function(node, table, cellIndex) {
        return $(node).find('strong').text();
    },
    // columnIndex : function ( original method )
    2 : function(node, table, cellIndex) {
        return $(node).find('img').attr('title');
    }
}

Warning What won't work is if you try to target the header using a filtering selector that uses an index, e.g. "th:eq()", ":gt()", ":lt()", ":first", ":last", ":even" or ":odd", ":first-child", ":last-child", ":nth-child()", ":nth-last-child()", etc.

As of version 2.16.0,

• The default text extraction method has been renamed and updated to get data from a data-attribute (set by the textAttribute option).
• If you need to support older versions of IE, this may add a significant delay to the table initialization especially for large tables; in this case, set the textExtraction option to any name other than "basic".
• Also, this option can now be set using a data-attribute named "data-text-extraction" on the table.

You can customize the text extraction by writing your own text extraction function "myTextExtraction" which you define like:

var myTextExtraction = function(node, table, cellIndex){
  // extract data from markup and return it
  // originally: return node.childNodes[0].childNodes[0].innerHTML;
  return $(node).find('selector').text();
}
$(function(){
  $("#myTable").tablesorter( { textExtraction: myTextExtraction } );
});

tablesorter will pass the current table cell object for you to parse and return. Thanks to Josh Nathanson for the examples; updated to a jQuery example by Rob G (Mottie).

Now if the text you are finding in the script above is say a number, then just include the headers sorter option to specify how to sort it. Also in this example, we will specify that the special textExtraction code is only needed for the second column (1 because we are using a zero-based index). All other columns will ignore this textExtraction function.

Added table and cellIndex variables to the textExtraction function in version 2.1.2 (this is not part of the original plugin).

$(function(){
  $("table").tablesorter({
    textExtraction: {
      1: function(node, table, cellIndex) {
           return $(node).find("span:last").text();
      }
    },
    headers: {
      1: { sorter : "digit" }
    }
  });
});

The built-in option is "basic" (modified v2.16.0) which is the equivalent of doing this inside of the textExtraction function: $(node).text();.

Notes about this namespace option:

• If a namesspace is not defined, a (hopefully) unique random namespace will be generated.
• If defined, any "non-word" characters (anything not "a-z", "0-9" or "_") within the namespace will be removed.
• Added or not, the namespace will be saved with a leading period (e.g. ".myuniquetableid")

$(function(){
  $("#mytable").tablesorter({
    // if table id = "mytable", this namespace is saved as ".mytable"
    namespace : $('#mytable')[0].id;
  });
});

Here is an example:

$(function(){
  $("table").tablesorter({
    numberSorter : function(a, b, direction, maxColumnValue){
      // direction; true = ascending; false = descending
      // maxColumnValue = the maximum value of that column (ignoring its sign)
      return a - b;
    }
  });
});

The direction parameter (boolean) is merely for informational purposes as the plugin automatically switches a and b depending on the sort direction ( i.e. there's no need to worry about reverse sorting, it's taken care of by the plugin ).

Change this option if want to change the click event that is bound to the table headers. Add multiple events separated by spaces.

Warning If this option is set to fire multiple events (e.g. 'mouseup pointerup'), sorting may be initialized twice in rapid succession and make it appear that nothing changed.

Change this option if you're using pointer events (or the pointer events polyfill). Add multiple events separated by spaces.

Warning If this option is set to fire multiple events (e.g. 'mousedown pointerdown'), sorting may be initialized twice in rapid succession and make it appear that nothing changed.

Change this option if you're using pointer events (or the pointer events polyfill). Add multiple events separated by spaces.

Warning If this option is set to fire multiple events (e.g. 'mouseup pointerup'), sorting may be initialized twice in rapid succession and make it appear that nothing changed.

Include a script like naturalSort.js as follows:

$(function(){
  $("table").tablesorter({
    textSorter : naturalSort
  });
});

or use the localeCompare sort

$(function(){
  $("table").tablesorter({
    // replace the OVERALL text sorter function
    textSorter: function(a, b, direction, columnIndex, table){
      // direction: true = ascending; false = descending
      // columnIndex: zero-based index of the current table column being sorted
      // table: table DOM element (access options by using table.config)
      return a.localeCompare(b);
    }
  });
});

In v2.12, the textSorter option will now accept a text sorter per column:

$(function(){
  $("table").tablesorter({
    textSorter : {
      // replace INDIVIDUAL COLUMN text sorter functions
      0 : function(a, b, direction, columnIndex, table){
        // same as $.tablesorter.sortText (basic alphabetical sort)
        // direction: true = ascending; false = descending
        // columnIndex: zero-based index of the current table column being sorted
        // table: table DOM element (access options by using table.config)
        return a > b ? 1 : (a < b ? -1 : 0);
      },
      1 : $.tablesorter.sortText,    // same as the function in column 0 above (modified in v2.12)
      2 : $.tablesorter.sortNatural, // renamed v2.12 from $.tablesorter.sortText - performs natural sort
      3 : Array.AlphanumericSort     // alphanumeric sort from sugar (http://sugarjs.com/arrays#sorting)
    }
  });
});

The direction parameter (boolean) is merely for informational purposes as the plugin automatically switches a and b depending on the sort direction ( i.e. there's no need to worry about reverse sorting, it's taken care of by the plugin ).

true	U.S.	1,234,567.89
false	German: French:	1.234.567,89 1 234 567,89

Prior to v2.4, this option set pixel widths to added colgroups to fix the column widths. This is useful for the Pager companion.
Requires the jQuery dimension plugin to work. This is now part of the jQuery core.

Previously documented widget options widgetZebra, widgetColumns and widgetUitheme will be retained for backwards compatibility.

Use the widgetOptions option as follows, please note that each option is followed by a comma (except the last one):

$(function(){
  $("table").tablesorter({

    // initialize a bunch of widgets (the order doesn't matter)
    widgets: ["zebra", "uitheme", "columns", "filter", "resizable", "stickyHeaders"],

    widgetOptions: {

      // *** columns widget ***
      // change the default column class names
      columns : [ "primary", "secondary", "tertiary" ],
      // include thead when adding class names
      columns_thead : true,
      // include tfoot when adding class names
      columns_tfoot : true,

      // *** filter widget ***
      // jQuery selector string (or jQuery object) of external anyMatch filter
      // filter_anyMatch   : null, // THIS OPTION WAS REMOVED IN V2.15
      // Include child rows content in the search
      filter_childRows     : false,
      // filter child row content by column, if true; filter_childRows must also be true!
      filter_childByColumn : false,
      // if true, include matching child row siblings
      filter_childWithSibs : true,
      // show column filters
      filter_columnFilters : true,
      // extra css class name (string or array) added to the filter element (input or select)
      filter_cellFilter    : '',
      // css class applied to the filter row inputs/select
      filter_cssFilter     : '',
      // data attribute in the header cell that contains the default filter value
      filter_defaultAttrib : 'data-value',
      // add a default column filter type "~{query}" to make fuzzy searches default; "{q1} AND {q2}" to make all searches use a logical AND.
      filter_defaultFilter : {},
      // filters to exclude, per column
      filter_excludeFilter : {},
      // jQuery selector string (or jQuery object) of external search inputs
      filter_external      : '',
      // class added to filtered rows; define in css with "display:none" to hide the filtered-out rows
      filter_filteredRow   : 'filtered',
      // add custom filter elements to the filter row
      filter_formatter     : null,
      // add custom filter functions using this option.
      filter_functions     : null,
      // hide filter row when table is empty
      filter_hideEmpty     : true,
      // if true, the filter row is hidden initially until hovered/focused.
      filter_hideFilters   : false,
      // if true, make all searches case-insensitive.
      filter_ignoreCase    : true,
      // if true, search column content while the user types (with a delay)
      filter_liveSearch    : true,
      // global query settings ('exact' or 'match'); overridden by "filter-match" or "filter-exact" class
      filter_matchType     : { 'input': 'exact', 'select': 'exact' },
      // a selector in a header with this class name will only show selected options in the drop down
      filter_onlyAvail     : 'filter-onlyAvail',
      // default placeholder text (overridden by any header "data-placeholder" setting)
      filter_placeholder   : { search : '', select : '' },
      // jQuery selector string of an element used to reset the filters.
      filter_reset         : null,
      // Reset filter input when the user presses escape - normalized across browsers
      filter_resetOnEsc    : true,
      // Use the $.tablesorter.storage utility to save the most recent filters
      filter_saveFilters   : false,
      // typing delay in milliseconds before starting a search.
      filter_searchDelay   : 300,
      // allow searching through already filtered rows in special circumstances; will speed up searching in large tables if true
      filter_searchFiltered: true,
      // include a function to return an array of values to be added to the column filter select
      filter_selectSource  : null,
      // filter_selectSource array text left of the separator is added to the option value, right into the option text
      filter_selectSourceSeparator : '|',
      // if true, filter start from the beginning of the cell contents.
      filter_startsWith    : false,
      // filter all data using parsed content.
      filter_useParsedData : false,
      // Set to true for server-side filtering
      filter_serversideFiltering :  false,

      // *** resizable widget ***
      // if false, resized columns are not saved for next page reload
      resizable : true,
      // if true, the last column will be resizable (use in non-full width tables)
      resizable_addLastColumn: false,
      // Add the starting & reset header widths
      resizable_widths : [],
      // throttle resizable event (needed for slow browsers)
      resizable_throttle : false,
      // target the last column for resize (like holding shift-drag)
      resizable_targetLast: false,

      // *** savesort widget ***
      // if false, the sort will not be saved for next page reload
      saveSort : true,

      // *** stickyHeaders widget ***
      // extra class name added to the sticky header row
      stickyHeaders : '',
      // jQuery selector or object to attach sticky header to
      stickyHeaders_attachTo : null,
      // jQuery selector or object to monitor horizontal scroll position (defaults: xScroll > attachTo > window)
      stickyHeaders_xScroll : null,
      // jQuery selector or object to monitor vertical scroll position (defaults: yScroll > attachTo > window)
      stickyHeaders_yScroll : null,
      // number or jquery selector targeting the position:fixed element
      stickyHeaders_offset : 0,
      // scroll table top into view after filtering
      stickyHeaders_filteredToTop: true,
      // added to table ID, if it exists
      stickyHeaders_cloneId : '-sticky',
      // trigger "resize" event on headers
      stickyHeaders_addResizeEvent : true,
      // if false and a caption exist, it won't be included in the sticky header
      stickyHeaders_includeCaption : true,
      // The zIndex of the stickyHeaders, allows the user to adjust this to their needs
      stickyHeaders_zIndex : 2,

      // *** storage widget ***
      // allows switching between using local & session storage
      storage_useSessionStorage : false,
      // alternate table id (set if grouping multiple tables together)
      storage_tableId  : '',
      // table attribute to get the table ID, if storage_tableId is undefined
      storage_group    : '', // defaults to "data-table-group"
      // alternate url to use (set if grouping tables across multiple pages)
      storage_fixedUrl : '',
      // table attribute to get the fixedUrl, if storage_fixedUrl is undefined
      storage_page     : '',

      // *** zebra widget ***
      // class names to add to alternating rows
      zebra : ["even", "odd"]

      // *** uitheme widget ***
      // use "config.theme" to set the theme to use

    }

  });
});

When using the checkbox parser, this class name is added to the row along with this class name plus the column index when the targeted checkbox is checked.

For example, if the named parser file has been loaded & "sorter-checkbox" class is added to the first column header, then any checked checkbox in the first column will have "checked checked-0" class names added to the row.

Checkboxes in any other column, not targeted by the parser, will be ignored and no extra row class names will be added.

When using the checkbox parser, this setting is used when a checkbox inside a header cell is changed; if true, only same column checkboxes within visible rows are modified to match the header checkbox.

If false, same column checkboxes in all rows are modified to match the status of the header checkbox.

This option is meant to be used with the jQuery Globalize library along with CLDR data.

See the Globalization section in the group widget demo for details on how to set it up.

Currently, the globalize (parser-globalize.js), month (parser-date-month.js) & weekday (parser-date-weekday.js) parsers utilize this option.

$(function(){
  $('table').tablesorter({
    // globalize : { lang: 'en' } // for ALL columns
    // or, per column by using the column index
    globalize : {
      0 : { lang: 'fr', Globalize : Globalize('fr'), raw: 'MMM d, y G' },
      2 : { lang: 'fr' }
    }
  });
});

Change this setting to grab a different image attribute to be used for sorting:

$(function(){
  $('table').tablesorter({
    // parse image title (value to be used while sorting & filtering)
    imgAttr : 'title',
    headers : {
      0 : { sorter: 'image' } // this parser is auto-detected, but will only work on the first image
    }
  });
});

This option was added to set a specific page when storing data using the $.tablesorter.storage code (v2.12).
More specifically, when the storage function is used, it attempts to give every table a unique identifier using both the page url and table ID (or index on the page if no id exists). This option allows you to override the current page url (it doesn't need to be a url, just some constant value) and save data for multiple tables across a domain.

The table url & id can also be overridden by setting table data attributes data-table-page (url) and data-table-group (id)
(e.g. <table class="tablesorter" data-table-page="mydomain" data-table-group="financial">...</table>)

For a bit more detail, specifically on how to use the new storage function options for a custom widget, please refer to issue #389.

This option was not working as intended, so it was completely removed - sorry for the lack of notice.

Previous default was "tablesorter-allowClicks"

Class name added to table header which allows clicks to bubble up. (added v2.18.1; removed in v2.20.0).

Default value: { css: [ "primary", "secondary", "tertiary" ] } (Object with Array)

When the column styling widget is initialized, it automatically applied the default class names of "primary" for the primary sort, "secondary" for the next sort, "tertiary" for the next sort, and so on (add more as needed)... (v2.0.17). Use the widgetColumns option to change the css class name as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["columns"], // initialize column styling of the table
    widgetColumns: { css: ["primary", "secondary", "tertiary" ] }
  });
});

Default value: { css: [ "ui-icon-arrowthick-2-n-s", "ui-icon-arrowthick-1-s", "ui-icon-arrowthick-1-n" ] } (Object with Array)

Used when the ui theme styling widget is initialized. It automatically applies the default class names of "ui-icon-arrowthick-2-n-s" for the unsorted column, "ui-icon-arrowthick-1-s" for the descending sort and "ui-icon-arrowthick-1-n" for the ascending sort. (v2.0.9). Find more jQuery UI class names by hovering over the Framework icons on this page: http://jqueryui.com/themeroller/

Use the widgetUitheme option to change the css class name as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["uitheme"], // initialize ui theme styling widget of the table
    widgetUitheme: {
      css: [
        "ui-icon-carat-2-n-s", // Unsorted icon
        "ui-icon-carat-1-s",   // Sort up (down arrow)
        "ui-icon-carat-1-n"    // Sort down (up arrow)
      ]
    }
  });
});

Default value: { css: [ "even", "odd" ] } (Object with Array)

When the zebra striping widget is initialized, it automatically applied the default class names of "even" and "odd". Use the widgetZebra option to change the css class name as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["zebra"], // initialize zebra striping of the table
    widgetZebra: { css: [ "normal-row", "alt-row" ] }
  });
});

Use the "columns" option to change the css class name as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["columns"], // initialize column styling of the table
    widgetOptions : {
      columns: [ "primary", "secondary", "tertiary" ]
    }
  });
});

Use the "columns_thead" option to add the column class names to the thead as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["columns"], // initialize column styling of the table
    widgetOptions : {
      columns_thead: true
    }
  });
});

Use the "columns_tfoot" option to add the column class names to the tfoot as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["columns"], // initialize column styling of the table
    widgetOptions : {
      columns_tfoot: true
    }
  });
});

*NOTE* When using this option, please be aware that all child row content will be obtained from each table cell using textContent, so none of the markup will be preserved. Also, carriage returns (<br>) will not be included. To account for the loss of white space, especially after carriage returns, please add an extra space to the end of the line. Using innerText, could have been an option for preserving the white space, but it is not standardized across all browsers (ref).

Use the filter_childRows option to include child row text as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_childRows : true
    }
  });
});

The filter_childRows option must also be true for this option to work.

If false, and the filter_childRows option is true, then queries in any column will search all child content, as before this option was added.

Use the filter_childByColumn option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_childRows : true,
      filter_childByColumn : true
    }
  });
});

Both filter_childRows & filter_childByColumn options must be set to true for this option to work.

If false, this option will only show the child row that matches the filter; and its parent row.

Use the filter_childWithSibs option as follows:

$(function(){
  $("table").tablesorter({
    widgets: [ "filter" ],
    widgetOptions : {
      filter_childRows     : true,
      filter_childByColumn : true,
      // only show matching child row & parent
      filter_childWithSibs : false
    }
  });
});

Use the filter_columnFilters option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_columnFilters : true
    }
  });
});

When the filter row is built, each table cell (<td>) will get the class name from this option.

• If this option is a plain string, all filter row cells will get the text applied as a class name.

  // "table-filter" class added to all filter row td's
  filter_cssFilter : 'table-filter'

• If this option is an array, then each filter row cell will get the text from the associate array element applied as a class name.

  .hidden { display: none; }

  // hiding second & fourth columns using associated css
  filter_cssFilter : [ '', 'hidden', '', 'hidden' ]

Use the filter_cellFilter option to add an extra css class name as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      // css class applied to the table row containing the filters & the inputs within that row
      // or [ "filter-cell0", "filter-cell1", "filter-cell2", etc... ]
      filter_cellFilter : "tablesorter-filter-cell"
    }
  });
});

Note The cells from this option are also contained within the config.$filters variable.

As of v2.15, this option can also contain an array of class names that are to be applied to input filters.

Changed default to an empty string in v2.11, as the "tablesorter-filter" class will always be added to the filter; this option now contains any additional class names to add.

Use the filter_cssFilter option to add an extra css class name as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      // css class applied to the table row containing the filters & the inputs within that row
      // or [ "filter0", "filter1", "filter2", etc... ]
      filter_cssFilter : "tablesorter-filter"
    }
  });
});

Warning If a column has a default filter set, the user will not be able to use other filters.

Use the filter_defaultFilter option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {

      filter_defaultFilter : {
        // target a column by class name or column index (zero-based)

        '.fuzzy' : '~{q}',
        2 : '{q}=',

        // for default "anyMatches" use the column length as the index
        // e.g. if your table has 5 columns (0,1,2,3,4), then set the anyMatch column as 5.
        5 : '{q} or {q}' // any match column
      }

    }
  });
});

Set up the column string as follows:

• Add the desired filter type symbol along with {query} or {q} to maintain positioning
• Symbols can be added to the beginning "~{query}" (default fuzzy search) or end "{q}=" (default exact search)
• For symbols that separate queries, like "AND", "OR" or "-" (range):
  • Add one additional {q} tag.
  • For example, to add a default "OR" search, use "{q} OR {q}".
  • If the user enters "a b c d" the column will be filtered using "a OR b OR c OR d", so there is no need to add more {q} tags within the string; adding more will likely mess up the results.
  • If the user only enters "a", then the column will be filtered using "a OR a" so as not to cause other issues.
• Note It is not possible to set up a default filter search within a query. So the "wild" filter search will not work as intended (e.g. {q}* and {q}? are essentially the same as {q}.

Use the filter_excludeFilter option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {

      filter_excludeFilter : {
        // target a column by class name or column index (zero-based)
        '.title' : 'range',

        // separate multiple filter types using spaces
        2 : 'range notMatch exact'
      }

    }
  });
});

Exclusion names must be separated by a comma. Here is a full list of filter type names:

• and - logical " AND " or && type filter.
• exact - exact match (using " or =).
• fuzzy - fuzzy match (~)
• notMatch - not match (! or !=)
• operators - comparison filters (< <= >= >)
• range - range ( - or to )
• regex - regex (/\d/)
• wild - wild card matching (? for single characters, * for multiple characters not including spaces, or | or OR for a logical OR.

Set this option to be a jQuery selector string, or jQuery object, pointing to any external inputs that are to be used for searching the table.

Use the filter_external option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_external : '.search'
    }
  });
});

These external inputs have one requirement, they must have a data-column="#", where the # targets the column (zero-based index), pointing to a specific column to search.

<input class="search" type="search" data-column="0" placeholder="Search first column">

If you want to search all columns, using the updated "any match" method, set the data column value to "all":

<input class="search" type="search" data-column="all" placeholder="Search entire table">

The updated any matching code will now automatically update all associated inputs with the latest search.
This option replaces filter_anyMatch.

*NOTE* If creating a custom theme, make sure to include this definition (set to display:none or the filter widget will appear to be broken!

In v2.17.0, the filter_formatter column can also be referenced by using a jQuery selector (e.g. class name or ID) that points to a table header cell.

filter_formatter : {
    ".col-value" : function($cell, indx){
      return $.tablesorter.filterFormatter.uiSpinner( $cell, indx, {
        ...
      });
    }
}

Warning What won't work is if you try to target the header using a filtering selector that uses an index, e.g. "th:eq()", ":gt()", ":lt()", ":first", ":last", ":even" or ":odd", ":first-child", ":last-child", ":nth-child()", ":nth-last-child()", etc.

A new file has been included named "widget-filter-formatter-jui.js" & "widget-filter-formatter-html5.js". The files include code to add jQuery UI and HTML5 controls via the filter_formatter option.

Most of the formatter functions have an option named valueToHeader which, when true adds a span to the header cell above the filter row and updates it with the current control's value (see example 2). If the option exists and is set to false, then the current value is added to the control's handle and css can be used to create a popup to show the current value (see example 1).

Another custom option named addToggle is included with the "uiSpinner", "html5Color" and "html5Number" code. This allows the user to disable the control to show all table rows. For the single sliders, "uiSlider" and "html5Range", the minimum value is used to clear the filter (show all rows).

The options included for each jQuery UI control only show basic options, but any or all of the jQuery UI options for that control can be included.

• To add the jQuery UI slider, follow this example:

  $(function(){
    $("table").tablesorter({
      widgets: ["filter"],
      widgetOptions : {
        filter_formatter : {
          // column index `0` or use a jQuery selector `"th:contains('Discount')"`
          0 : function($cell, indx){
            return $.tablesorter.filterFormatter.uiSpinner( $cell, indx, {
              value : 0,  // starting value
              min   : 0,  // minimum value
              max   : 50, // maximum value
              step  : 1,  // increment value by
              addToggle: true, // Add a toggle to enable/disable the control
              valueToHeader: false // add current slider value to the header cell
            });
          }
        }
      }
    });
  });

  Any of the other jQuery UI spinner widget options can also be included.
  
  
• Filter formatter functions include: "uiSpinner", "uiSlider", "uiRange" (uiSlider ranged), "uiDatepicker" (range only), "html5Number", "html5Range" and "html5Color".
• For other examples, please refer to the example pages. Formatter part 1 (example 1) adds jQuery UI controls to the filter row, while formatter part 2 (example 2) adds HTML5 controls, if supported, to the filter row.

In v2.22.0, a data parameter was added to that long list of parameters.

*WARNING* In a future update, the filter function parameters will be cleaned up and changed as follows!

filter_functions : {
  // function(e, n, f, i, $r, c, data) {} <- current parameters
  0 : function(c, data) {} // planned change (version undetermined)
}

The e (exact table cell text), n (normalized table cell text), f (filter input value), i (column index) and $r (current row; jQuery object) are all already included in the data object.

In v2.17.0, the filter_functions column can also be referenced by using a jQuery selector (e.g. class name or ID) that points to a table header cell.

filter_functions : {
    ".col-date" : {
        "< 2004" : function (e, n, f, i, $r, c, data) {
            return n < Date.UTC(2004, 0, 1); // < Jan 1 2004
        },
        ...
    }
}

Warning What won't work is if you try to target the header using a filtering selector that uses an index, e.g. "th:eq()", ":gt()", ":lt()", ":first", ":last", ":even" or ":odd", ":first-child", ":last-child", ":nth-child()", ":nth-last-child()", etc.

Use the "filter_functions" option in three different ways:

• Make a sorted select dropdown list of all column contents. Repeated content will be combined.

  $(function(){
    $("table").tablesorter({
      widgets: ["filter"],
      widgetOptions: {
        filter_functions: {
          // Add select menu to this column
          // set the column value to true, and/or add "filter-select" class name to header
          0 : true
        }
      }
    });
  });

  Alternately, instead of setting the column filter funtion to true, give the column header a class name of "filter-select". See the demo.
  
  
• Make a select dropdown list with custom option settings. Each option must have a corresponding function which returns a boolean value; return true if there is a match, or false with no match.

  Regex example

  $(function(){
    $("table").tablesorter({
      widgets: ["filter"],
      widgetOptions: {
        // function variables:
        // e = exact text from cell
        // n = normalized value returned by the column parser
        // f = search filter input value
        // i = column index
        // $r = jQuery element of current row
        // c = table.config
        // data = combined filter data - see filter widget "custom searches" demo, look under "How to add Custom filter types"
        filter_functions: {
          // Add these options to the select dropdown (regex example)
          2 : {
            "A - D" : function(e, n, f, i, $r, c, data) { return /^[A-D]/.test(e); },
            "E - H" : function(e, n, f, i, $r, c, data) { return /^[E-H]/.test(e); },
            "I - L" : function(e, n, f, i, $r, c, data) { return /^[I-L]/.test(e); },
            "M - P" : function(e, n, f, i, $r, c, data) { return /^[M-P]/.test(e); },
            "Q - T" : function(e, n, f, i, $r, c, data) { return /^[Q-T]/.test(e); },
            "U - X" : function(e, n, f, i, $r, c, data) { return /^[U-X]/.test(e); },
            "Y - Z" : function(e, n, f, i, $r, c, data) { return /^[Y-Z]/.test(e); }
          }
        }
      }
    });
  });

  Comparison example

  $(function(){
    $("table").tablesorter({
      widgets: ["filter"],
      widgetOptions: {
        // function variables:
        // e = exact text from cell
        // n = normalized value returned by the column parser
        // f = search filter input value
        // i = column index
        // $r = jQuery element of current row
        // c = table.config
        // data = combined filter data - see filter widget "custom searches" demo, look under "How to add Custom filter types"
        filter_functions: {
          // Add these options to the select dropdown (numerical comparison example)
          // Note that only the normalized (n) value will contain numerical data
          // If you use the exact text, you'll need to parse it (parseFloat or parseInt)
          4 : {
            "< $10"      : function(e, n, f, i, $r, c, data) { return n < 10; },
            "$10 - $100" : function(e, n, f, i, $r, c, data) { return n >= 10 && n <=100; },
            "> $100"     : function(e, n, f, i, $r, c, data) { return n > 100; }
          }
        }
      }
    });
  });

  Note: if the filter_ignoreCase option is true, it DOES alter the normalized value (n) by making it all lower case.
  
  
• Make a custom filter for the column.

  $(function(){
    $("table").tablesorter({
      widgets: ["filter"],
      widgetOptions: {
        // function variables:
        // e = exact text from cell
        // n = normalized value returned by the column parser
        // f = search filter input value
        // i = column index
        // $r = jQuery element of current row
        // c = table.config
        // data = combined filter data - see filter widget "custom searches" demo, look under "How to add Custom filter types"
        filter_functions: {
          // Exact match only
          1 : function(e, n, f, i, $r, c, data) {
            return e === f;
          }
        }
      }
    });
  });

  Note: if the filter_ignoreCase option is true, it DOES alter the normalized value (n) by making it all lower case.
  
  

Use the filter_hideEmpty option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_hideEmpty : false
    }
  });
});

Use the filter_hideFilters option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_hideFilters : true
    }
  });
});

You can change the style (thickness) of the hidden filter row in the tablesorter theme css. Look for .tablesorter-filter-row (revealed row) and .tablesorter-filter-row.hideme (for the hidden row) css definitions.

Use the filter_ignoreCase option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_ignoreCase : false
    }
  });
});

This option, when false allows you to disable the live search behavior, so that a filter is only applied when the user presses Enter (or uses Esc to clear and cancel the search).

If this option is set to a number, e.g. 4, a search of the column content will not initiate until this minimum number of characters are entered into the input.

A basic input filter will match the filter query until a "and" and "or" type search is performed.

By default, select filters and "and" and "or type searchs will look for an exact match, and to override this behavior you *had* to add a "filter-match" class to the columns to allow partial matches.

This option allows you to set a global "match" setting and save you the trouble of adding a bunch of classes.

There are only two options: "exact" and "match"; and it defaults to "exact" if anything else is entered.

In the demo, try searching for super or man in the first column.

In v2.17.6, columns with the only available class name set, that are not currently being filtered will only show the available options. Conversely, the column(s) with a selected option will show all options.

This option is useful after one or more columns have been filtered, then the column select filter with this class applied will only show the contents of the column within the dropdown that are currently visible. See the custom filter widget demo "Discount" column for an example (sort the "First Name" column first).

Caution: The main issue with this functionality is with keyboard accessibility. If the keyboard is used to select an option, only the first and default options will be available for chosing. The only way to select other options is with the mouse.

Any search type input added to the filter row will automatically get a placeholder attribute added, the source of this placeholder text is from the following sources, in order of priority:

• Header cell data (table.config.$headers.eq(0).data('placeholder', 'search for...');
• Header cell data-attribute (<th data-placeholder="Find Rank...">Rank</th>)
• Global filter_placeholder.search setting.

The filter_placeholder.select setting adds the text to the first select option (default option to show all rows).

Note: The widget-filter-formatter-jui.js jQuery UI Datepicker Range Selector creates two inputs, so this option then includes two additional settings:

filter_placeholder : {
	search : '',
	select : '',
	from   : '', // datepicker range "from" placeholder
	to     : ''  // datepicker range "to" placeholder
}

Note: The browser must support the placeholder attribute before it will be visible.

When this option points to a reset element using a jQuery selector string, it is bound using event delegation. So if any additional reset elements, with the same class name, are added to the page dynamically, they will be associated with the same table.

For example, add this button (<button class="reset">Reset</button>) to the table header, or anywhere else on the page. That element will be used as a reset for all column and quick search filters (clears all fields):

Use the filter_reset option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_reset : '.reset'
    }
  });
});

If this option contains a jQuery object (v2.16), clicking on any of the elements within that jQuery object will trigger a filter reset. If any additional elements with the same selector are added to the page, they will not be dynamically functional.

If either of these methods do not work as desired, simply trigger a filterReset event on the table.

Webkit browsers automatically clear the filter search input when pressing escape, but IE and Firefox do not. Setting this option to true, clears the filter input when the user presses escape.

When this option is set to false, pressing escape inside the search field is ignored.

Filters saved to local storage (or cookies) will override any default filters within the header data-attribute (set by the filter_defaultAttrib option) and be available to the pager before any ajax calls are made.

To bypass this behavior, clear out the saved filters as follows:

$.tablesorter.storage( $('table'), 'tablesorter-filters', '' );

Use the filter_searchDelay option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_searchDelay : 500
    }
  });
});

If you want to want to initialize the filter without user input, target any one of the filters and trigger a "search".

// target the first filter input
// this method will begin the search after the searchDelay time
$('input.tablesorter-filter:eq(0)').trigger('search');

// this method will begin the search immediately
$('input.tablesorter-filter:eq(0)').trigger('search', false);

In tablesorter v2.4+, the trigger can be applied directly to the table:

// refresh the widget filter; no delay
$('table').trigger('search', false);

To better explain this, lets do it by example. Lets say you have a column of color names and you enter "light" and results like "light blue" and "light grey" show up.

When you press the space bar, a space is added, and instead of searching though all of the colors again, the filter widget only searches through the already filtered results that started with "light". This can substantially speed up searching, especially in large tables.

But, there are some special circumstances which would make this method return incorrect results. So, this option was added to allow you to disable this feature in case one of these following conditions doesn't cover your need; but still, please report any issues!

The search through filtered results only occurs if the following conditions are met:

• The last search (for all columns) was not completely empty - all rows will be searched anyway.
• If there were no changes to the search from the beginning of the search string (changing the above search to "bright" will force a new search of all rows).
• If the search does not contain a logical or ( or or |), or a range delimiter ( - or to ) within the search query.
• If the search is not looking for an exact match (" or =) or a logical not search (!).
• Or, if the search is using a select dropdown without a "filter-match" class name (looking for an exact match).
• If the search does not contain an operator greater than or equal to a negative number (>=-10) or less than or equal to a positive number (<=10).
• And lastly, only search filtered rows if all rows are not hidden.

If the debug option is set to true, then a message will appear while filtering stating the specific number of rows, or "all" rows, that are being searched.

Use the filter_searchFiltered option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_searchFiltered : false
    }
  });
});

In v2.24.4, this option will now accept an array of objects which can contain extra information for each option. Here is an example modified from the filter selectmenu demo:

filter_selectSource  : {
  0 : [
    { value : '/\\.js$/',            'data-class' : 'ui-icon-script',   text : 'javascript' },
    { value : '/\\.(jpg|png|gif)$/', 'data-class' : 'ui-icon-image',    text : 'Image' },
    // plain strings are also acceptable - the string is added to both the text & value attribute
    'foobar',
    { value : '.css',                'data-class' : 'ui-icon-note',     text : 'CSS' },
    { value : '.html',               'data-class' : 'ui-icon-document', text : 'HTML page' },
    { value : '/\\.(json|txt|md)$/', 'data-class' : 'ui-icon-help',     text : 'Misc' },
  ]
}

• Each object entry must include a text property, or it will get ignored.
• If no value property is set, the option value will be equal to the text (IE requires a value defined for every option).
• Plain strings are still allowed within the array. If included, both the option text & value attribute will contain the string.
• *NOTE* when returning an array containing objects, the options will not be reduced to obtain unique selections.
• *NOTE* because this example is providing a fixed select option source, it can not support "filter-onlyAvail" (only show available options after filtering).

In v2.21.5, this option will now override the filter_function options (so you need to add them back!), allowing the addition of custom select options and still maintain basic filtering action - see this demo (ref).

In v2.17.0, the filter_selectSource column can also be referenced by using a jQuery selector (e.g. class name or ID) that points to a table header cell.

filter_selectSource : {
  ".model-number" : [ "abc", "def", "ghi", "xyz" ]
}

Warning What won't work is if you try to target the header using a filtering selector that uses an index, e.g. "th:eq()", ":gt()", ":lt()", ":first", ":last", ":even" or ":odd", ":first-child", ":last-child", ":nth-child()", ":nth-last-child()", etc.

A column will have a filter select dropdown when a "filter-select" class name is added to the header cell, or if the filter_functions column value is set to true

This option allows using an alternate source, or customizing options of the filter select dropdown. This option can be set as follows:

• null - this value will set the default behavior and return all table cell values from the current column.
• An overall function - when this option is a function, it will be used for all filter selects in the table.

  $(function(){
    $("table").tablesorter({
      widgets: ["filter"],
      widgetOptions : {
        filter_selectSource : function(table, column, onlyAvail){
          // get an array of all table cell contents for a table column
          var array = $.tablesorter.filter.getOptions(table, column, onlyAvail);
          // manipulate the array as desired, then return it
          return array;
        }
      }
    });
  });

• An object containing column keys set with a function - when the option is set in this manner, a function can be applied to a specific column.

  This example was updated in v2.23.4 to use the buildSelect function directly (ref)

  $(function(){
    $("table").tablesorter({
      widgets: ["filter"],
      widgetOptions : {
        filter_selectSource : {
          0 : function(table, column, onlyAvail){
            // call ajax after tablesorter has initialized; this prevents
            // multiple ajax calls during initialization
            if (table.hasInitialized) {
              $.getJSON('ajax/options.json', function(data) {
                // return false if there is a problem and the select
                // will display the original defaults
                var result = data.hasOwnProperty('options') ? data.options : false;
                // if not already done on the server-side & you want to sort & remove duplicates
                // from the results, use the processOptions function (added 2.23.4)
                result = $.tablesorter.filter.processOptions( table, column, result );
                // call the buildSelect function; pass `true` to replace the contents of the select
                $.tablesorter.filter.buildSelect( table, column, result, true, onlyAvail );
              });
            }
            return false;
          }
        }
      }
    });
  });

The function uses the following parameters:

• table - table DOM element
• column - zero-based index of the column with a filter select
• onlyAvail - boolean indicating if the returned options should only be from available (non-filtered) rows.

Important Return an array of values which will be added to the filter select dropdown. This array will automatically be stripped of any duplicate values and sorted alphanumerically before being added to the select. If for some reason the custom filter_selectSource function does not obtain the desired array of values, return false and the original method of obtaining column cell content will be used.

Use the filter_selectSourceSeparator option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_selectSource : {
        0 : [ 'en|English', 'fr|French', 'de|German' ]
      },
      // filter_selectSource array text left of the separator is added to the option value, right into the option text
      filter_selectSourceSeparator : '|'
    }
  });
});

Results in this HTML:

<select>
	<option value=""></option>
	<option value="en">English</option>
	<option value="fr">French</option>
	<option value="de">German</option>
</select>

This also works for the filter_functions

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions: {
      filter_functions: {
        // Add these options to the select dropdown (regex example)
        1 : {
          "<10|Less than 10" : function(e, n, f, i, $r, c, data) { return n < 10; },
          "10 - 100|Between 10 & 100" : function(e, n, f, i, $r, c, data) { return n >= 10 && n <=100; },
          ">100|Greater than 100" : function(e, n, f, i, $r, c, data) { return n > 100; }
        }
      },
      // filter_selectSource array text left of the separator is added to the option value, right into the option text
      filter_selectSourceSeparator : '|'
    }
  });
});

Results in this HTML (this adds a data-function-name attribute to keep a reference to the associated filter_functions.

<select>
  <option value=""></option>
  <option data-function-name="&lt;10|Less than 10" value="&lt;10">Less than 10</option>
  <option data-function-name="10 - 100|Between 10 &amp; 100" value="10 - 100">Between 10 & 100</option>
  <option data-function-name="&gt;100|Greater than 100" value="&gt;100">Greater than 100</option>
</select>

Use the filter_serversideFiltering option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_serversideFiltering : true
    }
  });
});

Use the filter_startsWith option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_startsWith : true
    }
  });
});

Use the filter_useParsedData option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_useParsedData : false
    }
  });
});

• To only use parsed data in specific columns, set this option to false and use any of the following (they all do the same thing), set in order of priority:
  • jQuery data data-filter="parsed".
  • metadata class="{ filter: 'parsed'}". This requires the metadata plugin.
  • headers option headers : { 0 : { filter : 'parsed' } }.
  • header class name class="filter-parsed".
• Remember that parsed data most likely doesn't match the actual table cell text, 20% becomes 20 and Jan 1, 2013 12:01 AM becomes 1357020060000.

Use the filter_defaultAttrib option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_defaultAttrib : 'data-value'
    }
  });
});

Then add the default filter value to the table header as follows:

<th data-value="<30">Age</th>

Changed to empty string in v2.11, as the "tablesorter-stickyHeader" class will always be added to the sticky header row; this option now contains any additional class names to add.

Previously, this option contained the class name to be applied to the sticky header row (tr) (v2.1).

Use the "stickyHeaders" option to add an extra css class name as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // css class name applied to the sticky header
      stickyHeaders : "tablesorter-stickyHeader"
    }
  });
});

So if your table ID is "gummy", then the cloned sticky table id becomes "gummy-sticky"

Use the "stickyHeaders_cloneId" option to change the cloned table id as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // cloned table id suffix
      stickyHeaders_cloneId : "-clone"
    }
  });
});

Use the stickyHeaders_includeCaption option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // cloned table id suffix
      stickyHeaders_includeCaption : false
    }
  });
});

Use the stickyHeaders_attachTo option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // Where to attach the stickyHeaders
      stickyHeaders_attachTo : '.wrapper' // $('.wrapper') jQuery object can also be used
    }
  });
});

If undefined (or null), the window element will be monitored.

Use the stickyHeaders_xScroll option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // jQuery selector or object to monitor horizontal scroll position (defaults: xScroll > attachTo > window)
      stickyHeaders_xScroll : '.wrapper' // $('.wrapper') jQuery object can also be used
    }
  });
});

If undefined (or null), the window element will be monitored.

Use the stickyHeaders_yScroll option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // jQuery selector or object to monitor vertical scroll position (defaults: yScroll > attachTo > window)
      stickyHeaders_yScroll : '.wrapper' // $('.wrapper') jQuery object can also be used
    }
  });
});

If the page includes a fixed navigation bar at the top, like Bootstrap, set "stickyHeaders_offset" option to offset the sticky table header to be below the fixed navigation by setting this option using any of the following examples:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // apply sticky header top 30px below the top of the browser window
      stickyHeaders_offset : 30
    }
  });
});

or

stickyHeaders_offset : '.navbar-fixed-top' // jQuery selector string

or

stickyHeaders_offset : $('.navbar-fixed-top') // jQuery object

When a user searches the table using the sticky header filter row the results may reduce the number of rows so that the table would scroll up out of the viewport. So, this option scrolls the table top into view and moves the filter focus to the same input in the original header, instead of the sticky header input.

Set this option to false to prevent the page scroll after filtering the table.

While this option is true, a timer is initialized to check the width of every header cell every 1/4 second. If this causes lag, or any other problems, set this option to false. When this option is false, sticky table headers are unable to detect and match the width of the original table headers when content is added or removed.

Use the "stickyHeaders_addResizeEvent" option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["resizable"],
    widgetOptions : {
      // add header resize detection
      stickyHeaders_addResizeEvent : true
    }
  });
});

When the browser window is resized, the headers (original and sticky) will resize automatically no matter the value of this option.

Use the stickyHeaders_zIndex option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["stickyHeaders"],
    widgetOptions : {
      // The zIndex of the stickyHeaders, allows the user to adjust this to their needs
      stickyHeaders_zIndex : 100
    }
  });
});

Use the "resizable" option to not save the resized widths:

$(function(){
  $("table").tablesorter({
    widgets: ["resizable"],
    widgetOptions : {
      // css class name applied to the sticky header
      resizable : false
    }
  });
});

If an anchor was included and the table is full width, the column would resize in the opposite direction which my not be intuitive to the user. So set this option as desired, but please be mindful of the user experience.

Use the "resizable_addLastColumn" option to include the last column resizer as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["resizable"],
    widgetOptions : {
      // css class name applied to the sticky header
      resizable_addlastcolumn : true
    }
  });
});

Use the "resizable_widths" option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["resizable"],
    widgetOptions : {
      // headers widths applied at initialization & resizable reset
      // this setting includes any non-resizable cells (resizable-false)
      resizable_widths : [ '10%', '10%', '50px' ]
    }
  });
});

When false throttling of the mousemove (resizing) event is not applied.

Set this option to either true for a default 5 millisecond delay, or set it to any number less than 10 to adjust the throttling delay that is applied to the mousemove/resizing event.

Use the "resizable_throttle" option as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["resizable"],
    widgetOptions : {
      // set to true for a default 5ms throttling delay
      // or set to a number < 10 (more than that makes the resizing adjustment unusable
      resizable_throttle : true
    }
  });
});

When true, resizing a column will change the size of the selected column, and the last column, not the selected column's neighbor.

When false, resizing a column will move the column border between it's neighbors.

Also, in a full width table, if this option is false, the same behavior as when this option is true can be seen when resizing a column while holding down the Shift key on the keyboard - the last column is resized.

Use the "saveSort" option to not save the current sort:

$(function(){
  $("table").tablesorter({
    widgets: ["saveSort"],
    widgetOptions : {
      // if false, the sort will not be saved for next page reload
      saveSort : false
    }
  });
});

If true, all saved variables for the table will be within the session storage. This means once the user closes the browser, all saved variables are lost.

Use the "storage_useSessionStorage" option to switch to session storage as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["saveSort"],
    widgetOptions : {
      // if false, saved variables will be saved in local storage
      storage_useSessionStorage : true
    }
  });
});

When grouping together multiple tables, setting the variable on one table will not cause the setting to modify a second table, the change will only be apparent on page reload.

If this option is not defined, the actual table id will be used (which isn't conducive to applying to multiple tables!)

A more detailed list of the table id priority settings can be found in the $.tablesorter.storage function description.

If a value is set in this option, the storage widget looks in that defined table data-attribute for a table id.

If this option is not defined, then the default data-attribute for the table becomes "data-table-group".

The value in the data-attribute sets a table id, if not found, the storage widget then looks for an id in the storage_tableId option.

This option replaces and will override the now deprecated config.fixedUrl option.

If there is a value within the table's "data-table-page" (set by the storage_page option), it will override this setting.

A more detailed list of the table url priority settings can be found in the $.tablesorter.storage function description.

If a value is set in this option, the storage widget looks in that defined table data-attribute for a table url.

If this option is not defined, then the default data-attribute for the table becomes "data-table-page".

The value in the data-attribute sets a table url, if not found, the storage widget then looks for a url in the storage_fixedUrl option.

Use the "zebra" option to change the theme as follows:

$(function(){
  $("table").tablesorter({
    widgets: ["zebra"], // initialize zebra striping of the table
    widgetOptions: {
      zebra: [ "normal-row", "alt-row" ]
    }
  });
});

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.container; additionally you can change the class name that is applied to the pager (used within the jquery.tablesorter.pager.css file) by modifying the widgetOption.pager_css.container class name (default is "tablesorter-pager")

This is some example pager markup. It should contain all of the controls set by the multiple css-named options:

<div class="pager">
  <form>
    <img src="first.png" class="first"/>
    <img src="prev.png" class="prev"/>
    <span class="pagedisplay"></span> <!-- this can be any element, including an input -->
    <img src="next.png" class="next"/>
    <img src="last.png" class="last"/>
    <select class="pagesize">
      <option value="10">10</option>
      <option value="20">20</option>
      <option value="30">30</option>
      <option value="40">40</option>
    </select>
    <select class="gotoPage" title="Select page number"></select>
  </form>
</div>

Caution If you use buttons in your pager container, make sure the buttons include a button type (<button type="button">Next</button>) to prevent form submission and page reloading every time the button is clicked.

Use this option as follows:

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      container: $(".pager")
    });
});

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_ajaxUrl

The tags within the ajaxUrl string are optional. If do not want the user to change the page size, then you only need to include the page in this string:

ajaxUrl: "http://mydatabase.com?start={page}"

If you need to send your server a page offset (actual starting record number), then you'll need to use the customAjaxUrl option.

Here is an example of how to include the option, it should always be paired with an ajaxProcessing function:

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      ajaxUrl: "http://mydatabase.com?page={page}&size={size}&{sortList:col}&{filterList:fcol}",
      ajaxProcessing: function(data, table, xhr){
        // do something with the ajax data
        return [ formatted_data, total_rows ];
      }
    });
});

The ajaxUrl template replaces the following tags with values from the tablesorter plugin and pager addon:

Tag	Replaced with
{page}	Zero-based index of the current pager page
{page+1}	One-based index of the current pager page (replace "+1" with any number) (e.g. {page+3}) (v2.9).
{size}	Number of rows showing, or number of rows to get from the server
{sortList:col} or {sort:col}	Adds the current sort to the ajax url string into a "col" array, so your server-side code knows how to sort the data (v2.4.5). The col portion of the {sortList:col} tag can be any name string (no spaces) to indicate the name of the variable to apply. So if your current sortList is [[2,0],[3,0]], it becomes "&sort[2]=0&sort[3]=0" in the url. {sort:col} shortened tag also works (v2.9).
{filterList:fcol} or {filter:fcol}	Adds the value of the current filters to the ajax url string into a "fcol" array, so your server-side code knows how to filter the data (v2.6). The fcol portion of the {filterList:fcol} tag can be any name string (no spaces) to indicate the name of the variable to apply. So if your current filters are ['','Blue',13], it becomes "&fcol[2]=Blue&fcol[3]=13" in the url. {filter:col} shortened tag also works (v2.9).

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_customAjaxUrl

The customAjaxUrl function has two parameters, the table DOM element and the processed url string (all tags within the ajaxUrl have been replaced with their appropriate values).

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      ajaxUrl: "http://mydatabase.com?page={page}&size={size}&{sortList:col}&{filterList:fcol}",
      ajaxProcessing: function(data, table, xhr){
        // do something with the ajax data
        return [ formatted_data, total_rows ];
      },
      // modify the url after all processing has been applied
      customAjaxUrl: function(table, url) {
        // trigger my custom event
        $(table).trigger('changingUrl');
        // send the server the current page
        return url += '&currntUrl=' + window.location.href;
      }
    });
});

In the following example, lets say your server needs a starting and ending record number instead of a page & size parameter. Use this option as follows:

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      ajaxUrl: "http://mydatabase.com?{sortList:col}",
      customAjaxUrl: function(table, url) {
        var pager = table.config.pager,
          start = pager.page * pager.size,
          end = start + pager.size;
        return url += '&start=' + start + '&end=' + end;
      },
      ajaxProcessing: function(data, table, xhr){
        // do something with the ajax data
        return [ total_rows, data ];
      }
    });
});

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_ajaxObject

The ajaxObject is completely customizable, except for the url setting which is processed using the pager's ajaxUrl and customAjaxUrl options. This means you can also add a success callback function which is called after the ajax has rendered.

Your server does not need to return a JSON format, if you want to return pure HTML, set the dataType to "html" and modify the ajaxProcessing function to instead work with HTML; then return a jQuery object or apply the HTML to the table yourself.

See all possible settings in the jQuery.ajax documentation

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      ajaxUrl: "http://mydatabase.com?page={page}&size={size}&{sortList:col}&{filterList:fcol}",
      ajaxObject: {
        // add more ajax settings here
        // see http://api.jquery.com/jQuery.ajax/#jQuery-ajax-settings
        dataType: 'json'
      },
      ajaxProcessing: function(data, table, xhr){
        // do something with the ajax data;
        return [ total_rows ];
      }
    });
});

In v2.23.1

• A settings parameter was added before the exception parameter to exactly match the parameters returned by the jQuery .ajaxError() method.
• This function is now always called, even if the $.tablesorter.showError function is called by an external function with only a string.

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_ajaxError

When there is an ajax error, the $.tablesorter.showError function is called. In v2.23.0, that function now checks this callback to allow adding a custom error message.

Use it as follows:

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      ajaxError: function( config, xhr, settings, exception ) {
        // returning false will abort the error message
        // the code below is the default behavior when this callback is set to `null`
        return
          xhr.status === 0 ? 'Not connected, verify Network' :
          xhr.status === 404 ? 'Requested page not found [404]' :
          xhr.status === 500 ? 'Internal Server Error [500]' :
          exception === 'parsererror' ? 'Requested JSON parse failed' :
          exception === 'timeout' ? 'Time out error' :
          exception === 'abort' ? 'Ajax Request aborted' :
          'Uncaught error: ' + xhr.statusText + ' [' + xhr.status + ']' );
      }
    });
});

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_initialRows

Use this option as follows:

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      processAjaxOnInit: false,
      initialRows: {
        total: 100,
        filtered: 100
      },
      // other ajax settings...
    });
});

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_processAjaxOnInit

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_ajaxProcessing

This function was created and modified to allow you a great deal of flexibility. The only required information that this function needs to return is an array containing the total number of rows, which is needed to calculate total pages.

There are numerous examples below. Choosing which one to use is left to you. For more information, please check out related questions on Stackoverflow, in particular see this thread about how to use the different ajax options together.

In v2.10, the returned rows is now optional. And it can either be an array of arrays or a jQuery object (not attached to the table)

Process your ajax data so that the following information is returned:

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_output

This option replaced the original separator option, which only separated the page number from the total number of pages. The formatted output from this option is placed inside the information block targeted by the cssPageDisplay option.

Use it as follows:

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      output: '{startRow} to {endRow} of {totalRows} rows'
    });
});

The following tags are replaced within the output string:

Tag	Replaced with
{size}	The current pager size
{page}	The current pager page
{page:input}	The current pager page within an input (v2.17.6)
{totalPages}	Total number of pager pages
{filteredPages}	Total number of pages left after being filtered
{startRow}	Starting row number currently displayed
{startRow:input}	Starting row number currently displayed within an input (v2.17.6)
{endRow}	Ending row number currently displayed
{filteredRows}	Total number of rows left after being filtered
{totalRows}	Total number of rows

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_updateArrows

If true the classname from the cssDisabled option is applied to the arrows when at either page extreme.

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_startPage

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_pageReset

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_size

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_savePages

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_storageKey

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_fixedHeight

This option replaced the original positionFixed and offset options which set the absolute position of the pager block.

If true, it should maintain the height of the table, even when viewing fewer than the set number of records (go to the last page of any demo to see this in action). It works by adding an empty row to make up the differences in height.

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_countChildRows

*CAUTION* When true, child row(s) may not appear to be attached to its parent row, may be split across pages or may distort the table if rowspan or cellspans are included within the child row.

If this option is false, child row(s) will always appear on the same page as its parent.

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_removeRows

The original tablesorter plugin (v2.0.5) removed rows automatically, without providing an option. It really does speed up sorting of very large tables, but also breaks updating and modifying table content dynamically.

If this option is false, the addon only hides the non-visible rows; this is useful if you plan to add/remove rows with the pager enabled.

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.first

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.prev

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.next

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.last

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.gotoPage (changed from goto in v2.17.3)

Please note that this select dropdown is initially empty and automatically updated by the plugin with the correct number of pages, which depends on the size setting.

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.pageDisplay

In the original tablesorter (v2.0.5) this option could only target an input, it was updated (v2.0.9) to display the formatted output from the output option inside of any element (span, div or input).

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_selectors.pageSize

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_css.errorRow

Note there is no period "." in front of this class name (it is not a selector).

Note The pager widget equivalent option is within the widgetOptions and accessed via widgetOptions.pager_css.disabled

More explicitly, this class is applied to the pager arrows when they are at either extreme of pages and the updateArrows option is true. When the pager has been disabled, this class is applied to all controls.

Note there is no period "." in front of this class name (it is not a selector).

This option has been replaced by the filter_external option.

Show any rows that match a search query. If this option is true any column match will show that row; but there are limitations (v2.13.3).

It is best if this filter_anyMatch option is used with a single search input as follows:

<input class="search" type="search">
<button type="button" class="reset">Reset Search</button>

$(function(){
  $("table").tablesorter({
    widgets: ["filter"],
    widgetOptions : {
      filter_anyMatch : true,
      filter_columnFilters: false,
      filter_reset: '.reset'
    }
  });

  // Target the $('.search') input using built in functioning
  // this binds to the search using "search" and "keyup"
  // Allows using filter_liveSearch or delayed search &
  // pressing escape to cancel the search
  $.tablesorter.filter.bindSearch( $table, $('.search') );

});

This option contains the name of the theme. Currently jQuery UI ("jui") and Bootstrap ("bootstrap") themes are supported (updated v2.4)

* NOTE * only the uitheme widget option was removed. All of the information below is still pertinent and portions have been copied to the core theme option.

To modify the class names used, extend from the $.tablesorter.themes variable as follows:

// Extend the themes to change any of the default class names ** NEW **
$.extend($.tablesorter.themes.jui, {
  // change default jQuery uitheme icons - find the full list of icons
  // here: http://jqueryui.com/themeroller/ (hover over them for their name)
  table      : 'ui-widget ui-widget-content ui-corner-all', // table classes
  header     : 'ui-widget-header ui-corner-all ui-state-default', // header classes
  footerRow  : '',
  footerCells: '',
  icons      : 'ui-icon', // icon class added to the <i> in the header
  sortNone   : 'ui-icon-carat-2-n-s',
  sortAsc    : 'ui-icon-carat-1-n',
  sortDesc   : 'ui-icon-carat-1-s',
  active     : 'ui-state-active', // applied when column is sorted
  hover      : 'ui-state-hover',  // hover class
  filterRow  : '',
  even       : 'ui-widget-content', // even row zebra striping
  odd        : 'ui-state-default'   // odd row zebra striping
});

This widget option replaces the previous widgetUitheme. All theme css names are now contained within the $.tablesorter.themes variable. Extend the default theme as seen above.

The class names from the $.tablesorter.themes.{name} variable are applied to the table as indicated.

As before the jQuery UI theme applies the default class names of "ui-icon-arrowthick-2-n-s" for the unsorted column, "ui-icon-arrowthick-1-s" for the descending sort and "ui-icon-arrowthick-1-n" for the ascending sort. (Modified v2.1; Updated in v2.4). Find more jQuery UI class names by hovering over the Framework icons on this page: http://jqueryui.com/themeroller/

Use the "uitheme" option to change the css class name as follows:

$(function(){
  $("table").tablesorter({
    theme     : 'jui',       // set theme name from $.tablesorter.themes here
    widgets   : ["uitheme"], // initialize ui theme styling widget of the table
    widgetOptions: {
      uitheme : "jui"        // this is now optional in v2.7, it is overridden by the theme option
    }
  });
});

To add a new theme, define it as follows; replace "custom" with the name of your theme:

$.tablesorter.themes.custom = {
  table      : 'table',       // table classes
  header     : 'header',      // header classes
  footerRow  : '',
  footerCells: '',
  icons      : 'icon',        // icon class added to the <i> in the header
  sortNone   : 'sort-none',   // unsorted header
  sortAsc    : 'sort-asc',    // ascending sorted header
  sortDesc   : 'sort-desc',   // descending sorted header
  active     : 'sort-active', // applied when column is sorted
  hover      : 'hover',       // hover class
  filterRow  : 'filters',     // class added to the filter row
  even       : 'even',        // even row zebra striping
  odd        : 'odd'          // odd row zebra striping
}

The original tablesorter pager plugin absolutely positioned the pager controls at the bottom of the table. It appears that this option was intended to tweak the position of the pager container. The option exists, but no code was found.

If this option were true, the original tablesorter pager plugin would absolutely position the pager controls at the bottom of the table.

The original tablesorter pager plugin would combine the current page with the calculated total number of pages within the cssPageDisplay with this separator string inbetween.

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
  $rows = $( 'tr.addedRows' ), // jQuery selector of newly appended row(s)
  // applies or reapplies a sort to the table; use false to not update the sort
  resort = true, // or [ [0,0], [1,0] ] etc
  callback = function( table ) {
    // do something
  };
$.tablesorter.addRows( config, $rows, resort, callback );

Triggered event method:

It does not work the same as "update" in that it only adds rows, it does not remove them.

Also, use this method to add table rows while using the pager plugin. If the "update" method is used, only the visible table rows continue to exist.

// Add multiple rows to the table
var row = '<tr><td>Inigo</td><td>Montoya</td><td>34</td>' +
  '<td>$19.99</td><td>15%</td><td>Sep 25, 1987 12:00PM</td></tr>',
  $row = $( row ),
  // resort table using true to reapply the current sort; set to false to prevent resort
  // if undefined, the resort value will be obtained from config.resort (added v2.19.0)
  // As of v2.19.0, the resort variable can contain a new sortList to be applied
  // A callback method was added in 2.3.9.
  resort = true, // or [ [0,0], [1,0] ] etc
  callback = function( table ){
    alert( 'rows have been added!' );
  };
$( 'table' )
  .find( 'tbody' ).append( $row )
  .trigger( 'addRows', [ $row, resort, callback ] );

---

• In v2.23.0,
  • If a table contains only one tbody (not counting information only tbodies; which have a class name from cssInfoBlock), then a row string can be used in this method.

    var $table = $( 'table' ),
    config = $table[ 0 ].config;
    // triggered event method
    $table.trigger( 'addRows', [ '<tr>...</tr>', true ] );
    
    // direct method
    $.tablesorter.addRows( config, '<tr>...</tr>', true );

  • So instead of making a jQuery object, appending it to the table, then passing the reference to the method, you can just pass a string. This method doesn't work if a table has multiple tbodies, because the plugin doesn't know where you want to add the rows.
• In v2.16.1, the $row parameter can be a row DOM element or jQuery object.

Using this method will clear out any settings that have changed since the table was initialized (refreshes the entire table); so any sorting or modified widget options will be cleared.
However, it will not clear any values that were saved to storage. This method is basically like reloading the page.

$('table').trigger('resetToLoadState');

// Target a specific header
$('table').find('th:eq(2)').trigger('sort');

Using this method will maintain the sorting order; so, if the column is already sorted in ascending order, this method will act as if you manually clicked on the header. Whatever sort order is applied is dependent on other option settings such as initialSortOrder, lockedOrder (set within the headers), sortReset option, sortRestart and will be ignored if the column sort is disabled (sorter: false).

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
	sort = [ [ 0,0 ], [ 1,0 ] ],
	callback = function( table ) {
		// do something
	};
	// NOTE: the triggered 'sorton' method requires the sort & callback methods to be
	// passed inside an array, this direct method does not.
	// Also, notice the "O" of "sortOn" is capitalized in this direct method
$.tablesorter.sortOn( config, sort, callback );

Triggered event method:

// Choose a new sort order
var sort = [ [0,0], [2,0] ],
    callback = function( table ){
        alert( 'new sort applied to ' + table.id );
    };
// Note that the sort value below is inside of another array (inside another set of square brackets)
// without a callback it could look like this:
$( 'table' ).trigger( 'sorton', [ [[0,0],[2,0]] ] );

// when including a callback method the outer square bracket wrap both parameters (added in 2.3.9).
$( 'table' ).trigger( 'sorton', [ sort, callback ] );

*NOTE* using this method to sort ignores the additions from the sortForce and sortAppend options.

In v2.17.0, the sort direction can be set using "a" (ascending), "d" (descending), "n" (next), "s" (same) & "o" (opposite).

$('table').trigger('sorton', [ [[0,"a"],[2,"n"]] ]);

Please try out the demo (example link) to better understand how these values work.

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
	callback = function( table ) {
		// do something
	};
$.tablesorter.sortReset( config, callback );

Triggered event method:

This method immediately resets the entire table sort, while the option only resets the column sort after a third click.

In v2.16.0, a callback function was added to this method.

// Reset the table (make it unsorted)
var callback = function( table ) {
	console.log( 'sort has been reset' );
};
$( 'table' ).trigger( 'sortReset', [ callback ] );

*NOTE* Don't confuse this method with the sortReset option.

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
	// applies or reapplies a sort to the table; use false to not update the sort
	resort = true, // or [ [0,0], [1,0] ] etc
	callback = function( table ) {
		// do something
	};
$.tablesorter.update( config, resort, callback );

Triggered event method:

// Add new content
$( 'table tbody' ).append( html );

// let the plugin know that we made a update
// the resort flag set to true will trigger an automatic resort using the current sort
// if set to false, no new sort will be applied; or set it to any sortList value (e.g. [[0,0]]; new v2.19.0)
// A callback method was added in 2.3.9.
var resort = true,
    callback = function( table ){
        alert( 'new sort applied' );
    };
$( 'table' ).trigger( 'update', [ resort, callback ] );

// As of version 2.19.0, if the resort parameter is undefined, the setting from the config.resort will be used

// As of version 2.0.14, the table will automatically resort after the update (if the "resort" flag is true
// & will use the current sort selection), so include the following if you want to specify a different sort

// set sorting column and direction, this will sort on the first and third column
var sorting = [ [2,1], [0,0] ];
// method to use prior to v2.19.0
// $( 'table' )
//  .trigger( 'update', [ false ] )
//  .trigger( 'sorton', [ sorting ] );
// After v2.19.0; do the following to apply a new sort after updating
// if sorting is an empty array [], then the sort will be reset
$( 'table' ).trigger( 'update', [ sorting ] );

NOTE Don't confuse this method with the sortReset option. updateRows was added to work around the issue of using jQuery with the Prototype library. Triggering an "update" would make Prototype clear the tbody; Please see issue #217 for more details.

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
	// applies or reapplies a sort to the table; use false to not update the sort
	resort = true, // or [ [0,0], [1,0] ] etc
	callback = function( table ) {
		// do something
	};
$.tablesorter.updateAll( config, resort, callback );

Triggered event method:

// Change thead & tbody column of cells
// remember, "eq()" is zero based & "nth-child()" is 1 based
$("table thead th:eq(2)").html("Number");
// add some random numbers to the table cell
$("table tbody").find('td:nth-child(3)').html(function(i,h){
  return Math.floor(Math.random()*10) + 1; // random number from 0 to 10
});

// reapply the current sort if resort = true
// do not reapply the current sort if resort = false
// if undefined, resort will be obtained from config.resort (added v2.19.0)
// as of v2.19.0, apply a new sort if resort = [[0,0]] (or whatever)
// or the sort is reset if resort = []
var resort = true,
  // add a callback, as desired
  callback = function(table){
    alert('table updated!');
  };

// let the plugin know that we made a update, then the plugin will
// automatically sort the table based on the header settings
$("table").trigger("updateAll", [ resort, callback ]);

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
	// optional parameter to target tbodies
	$tbodies = $( 'table' ).children( 'tbody.totals' ),
	callback = function( table ) {
		// do something
	};
$.tablesorter.updateCache( config, callback, $tbodies );

Triggered event method:

*NOTE* In v2.22.2, a new parameter was added to allow passing a jQuery object containing tbodies to be added to the table (for the tbody sorting widget).

This method is used by the pager (addon & widget) to update the data stored within the cache after the content has been updated using ajax.

// optional callback function
var callback = function( table ){ /* do something */ },
	// optional in v2.22.2; defaults to table.config.$tbodies if undefined
	$tbodies = $( 'table' ).children( 'tbody' );
$("table").trigger("updateCache", [ callback, $tbodies ] );

This method was originally designed to be used with the pager. It should be used under these conditions:

• When the pager removeRows option is true.
• When not using the "updateCell" or "addRows" methods.
• Before manually adding or removing table rows.
• And, before triggering an "update".

Note: The entire table is stored in the cache, but when using the pager with the removeRows option set to true, only the visible portion is actually exists within the table. So, use this option to add all stored rows back into the table before manually changing the contents. Otherwise, if any update method is triggered, only the visible rows will be added back to the cache.

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config;
// there is no callback available when using this direct method because
// it may divert to pager injected functions, if the pager is being used
$.tablesorter.appendCache( config );

Triggered event method:

// how to update the table contents
$("table")
  .trigger("appendCache")
  .append('<tr>...</tr>') // add new row(s), or delete rows
  .trigger("update"); // update the cache

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
	callback = function( table ) {
		// do something
	};
$.tablesorter.updateHeaders( config, callback );

Triggered event method:

$(function() {
  $( 'table' ).tablesorter();

  // click on a button somewhere on the page to update header index
  $( 'button' ).click( function() {
    // Do something after the cell update in this callback function
    var $headerCell = $('thead th:eq(1)'),
      index = $headerCell.data( 'counter' ) || 0,
      callback = function( table ) {
          /* do something */
        };

    // change header text
    $headerCell
      .html( 'header click #' + index )
      // update header data
      .data( 'counter', index++ );

    // update the header, includes rebinding events & using the header template
    $( 'table' ).trigger( 'updateHeaders', callback );
    return false;
  });
});

Direct method:

In v2.23.0, this method can be called directly as follows:

var config = $( 'table' )[ 0 ].config,
	$cell = $( 'td.random' ), // jQuery selector or DOM element of newly updated cell
	// applies or reapplies a sort to the table; use false to not update the sort
	resort = true, // or [ [0,0], [1,0] ] etc
	callback = function( table ) {
		// do something
	};
$.tablesorter.updateCell( config, $cell, resort, callback );

Triggered event method:

$(function() {
  $( 'table' ).tablesorter();

  $( 'td.discount' ).click( function() {

    // Do we want to reapply the current sort on the column?
    // see updateRow for other resort settings as of v2.19.0
    // if resort is undefined, the value from config.resort (added v2.19.0) will be used
    var resort = false,
        // Do something after the cell update in this callback function
        callback = function( table ) {
          /* do something */
        },
        // randomize a number & add it to the cell
        discount = '$' + Math.round( Math.random() * Math.random() * 100 ) + '.' +
          ( '0' + Math.round( Math.random() * Math.random() * 100 ) ).slice( -2 );

    // add new table cell text
    $( this ).text( discount );

    // update the table, so the tablesorter plugin can update its value
    // set resort flag to false to prevent automatic resort (since we're using a different sort below)
    // prior to v2.19.0, leave the resort flag as undefined, or with any other value, to automatically resort the table
    // new resort values can be set as of v2.19.0 - please see the "updateRow" documentation for more details
    // $( 'table' ).trigger( 'updateCell', [ this ] ); < - resort is undefined so the table WILL resort
    $( 'table' ).trigger( 'updateCell', [ this, resort, callback ] );

    // As of version 2.0.14, the table will automatically resort (using the current sort selection)
    // after the update, so include the following if you want to specify a different sort

    // prior to v2.19.0, set sorting column and direction, this will sort on the first and third column
    // after v2.19.0, add any new sort to the "resort" variable above
    var sorting = [ [ 3,1 ] ];
    $( 'table' ).trigger( 'sorton', [ sorting ] );

    return false;
  });
});

In v2.25.4, the direct method will now correctly accept $('table'). Previously, only $('table')[0] would work.

In v2.25.0, this method ensures that the widget initialization code is executed as well as the format function. So now a widget that was not previously initialized or had been previously removed, can be reapplied.

Only one widget can be applied at a time using this method.

Direct method:

$.tablesorter.applyWidgetId( $('table'), 'zebra' );

Triggered event method:

$(function(){
  // initialize tablesorter without the widget
  $('table').tablesorter();

  // click a button to apply the zebra striping
  $('button').click(function(){
    $('table').trigger('applyWidgetId', 'zebra');
    return false;
  });

});

This method only updates the widgets listed in the table.config.widgets option.

// This method applies the widgets already added to tablesorter
$('table').trigger('applyWidgets');

Use this method can be used to add multiple widgets to the table.

var $table = $( 'table' );
$table[0].config.widgets = [ 'zebra', 'columns' ];
$table.trigger('applyWidgets');

This method will remove the named widget(s) from the table.

Direct method:

$.tablesorter.removeWidget( $( 'table' ), widget );

Triggered event method:

$( 'table' ).trigger( 'removeWidget', widget );

The widget parameter can be used as follows:

• Single widget name - string

  // only remove zebra widget
  $( 'table' ).trigger( 'removeWidget', 'zebra' );

• Multiple widgets names - array or string (space or comma separated)

  // remove multiple widgets (the below methods are all equivalent)
  $( 'table' ).trigger( 'removeWidget', 'zebra columns' );
  $( 'table' ).trigger( 'removeWidget', 'zebra, columns' );
  $( 'table' ).trigger( 'removeWidget', [ 'zebra', 'columns' ] );

• true - boolean (removes all widgets; passing false does nothing)

  // remove all widgets
  $( 'table' ).trigger( 'removeWidget', true );

// Remove tablesorter and all classes
$("table").trigger("destroy");

// Remove tablesorter and all classes but the "tablesorter" class on the table
// callback is a function
$("table").trigger("destroy", [false, callback]);

Trigger this method using either of the following methods (they are equivalent):

// trigger a refresh widget event
$('table').trigger('refreshWidgets', [doAll, dontapply]);

// Use the API directly
$.tablesorter.refreshWidgets(table, doAll, dontapply)

• If doAll is true it removes all widgets from the table. If false only non-current widgets (from the widgets option) are removed.
• When done removing widgets, the widget re-initializes the currently selected widgets, unless the dontapply parameter is true leaving the table widget-less.
• Note that if the widgets option has any named widgets, they will be re-applied to the table when it gets resorted. So if you want to completely remove all widgets from the table, also clear out the widgets option $('table')[0].config.widgets = [];

This first method sends an array with the search strings to the filter widget.

$(function(){
  // apply "2?%" filter to the fifth column (zero-based index)
  var columns = [];
  columns[4] = '2?%'; // or define the array this way [ '', '', '', '', '2?%' ]
  $('table').trigger('search', [columns]);
});

or, directly add the search string to the filter input as follows:

$(function(){
  // apply "2?%" filter to the fifth column (zero-based index)
  $('table').find('input.tablesorter-filter').eq(4).val('2?%');
  $('table').trigger('search', false); // add a false flag to skip the search delay
});

In v2.15, one additional parameter can be added to the array to perform an "any-match" of the table; Warning! please note that if no external input (with a data-column="all" is attached using bindSearch function) is visible, the user will not know that a filter has been applied.

// in a table with 4 columns; set the 5th parameter to any-match
$('table').trigger( 'search', [['', '', '', '', 'orange']] ); // find orange in any column

If you are using the filter_formatter option to add custom input elements, this function may not work on those columns. Please refer to the filter_formatter section for more details.

$(function(){
  // this is the same code that the "filter_reset" element runs to clear out the filters.
  $('button').click(function(){
    $('table').trigger('filterReset');
    return false;
});

This method is used by the filter_reset option when defined.

Use this as follows:

$(function(){
  // this is the same code that the "filter_reset" element runs to clear out the filters.
  $('button').click(function(){
    $('#myTable').trigger('filterResetSaved');
    return false;
});

This is the equivalent of executing this function:

// clear the current table stored filters
$.tablesorter.storage( $('#myTable'), 'tablesorter-filters', '' );

$(function(){
  $('button').click(function(){
    $('table').trigger('saveSortReset');
    return false;
  });
});

$(function(){
  $('table').trigger('pageSize', 15);
});

In v2.24.0, this option will now accept "all" as a setting, and in turn display all rows.

If no value is passed, the pager will reset to page 1; otherwise, pass a "one-based" index of the desired page

$(function(){
  $('table').trigger('pageSet', 3); // pass a one-based index
});

If no value is passed, the pager will reset to page 1 with the original pager size setting; otherwise, pass a "one-based" index of the desired page and the pager size as an array

$(function(){
  $('table').trigger('pageAndSize', [ 2, 20 ]); // pass a one-based page index & page size
});

In v2.24.0, this option will now accept "all" as a page size setting, and in turn display all rows; the page number will be force to page one.

If there is a need, this method will force the (ajax and non-ajax) pager to update. Use it as follows:

$(function(){
  $('table').trigger('pagerUpdate');
});

Or, if you need, you can optionally pass a new page number:

$(function(){
  $('table').trigger('pagerUpdate', 3); // update and set to page 3
});

In v2.23.0, this method was changed from destroy.pager to destroyPager because of issues with unique namespacing.

$(function(){
  $('table').trigger('destroyPager');
});

The only way to restore the pager addon is to re-initialize the pager addon:

$(function(){
  $('table').tablesorterPager(pagerOptions);
});

In v2.23.0, this method was changed from disable.pager to disablePager because of issues with unique namespacing.

The disabled state will reveal all table rows and disable, but not hide, pager controls.

$(function(){
  $('table').trigger('disablePager');
});

In v2.23.0, this method was changed from enable.pager to enablePager because of issues with unique namespacing.

$(function(){
  $('table').trigger('enablePager');
});

$(function(){

  // bind to initialized event BEFORE initializing tablesorter*
  $("table")
    .bind("tablesorter-initialized",function(e, table) {
      // do something after tablesorter has initialized
    });

  // initialize the tablesorter plugin
  $("table").tablesorter({
    // this is equivalent to the above bind method
    initialized : function(table){
      // do something after tablesorter has initialized
    }
  });

});

* Note: bind to all initialization events before initializing tablesorter; because most of the time, if bound after, the events will fire before the binding occurs.

$(function(){

  // initialize the tablesorter plugin
  $("table").tablesorter();

  // bind to sort events
  $("table").bind("sortBegin",function(e, table) {
    // do something crazy!
  });
});

$(function(){

  // initialize the tablesorter plugin
  $("table").tablesorter();

  // bind to sort events
  $("table")
    .bind("sortStart",function(e, table) {
      $("#overlay").show();
    })
    .bind("sortEnd",function(e, table) {
      $("#overlay").hide();
    });
});

$(function(){

  // initialize the tablesorter plugin
  $("table").tablesorter();

  // bind to sort events
  $("table")
    .bind("sortStart",function(e, table) {
      $("#overlay").show();
    })
    .bind("sortEnd",function(e, table) {
      $("#overlay").hide();
    });
});

This occurs after an "update", "updateAll", "updateCell" or "addRows" method was called, but before any callback functions are executed.

$(function(){

  // initialize the tablesorter plugin
  $('table')
    .tablesorter()
    // bind to sort events

    .bind('updateComplete', function(e, table) {
      // do something after the table has been altered;
    });

});

This event occurs after an "updateComplete" and "pagerComplete" event. There may be some other table interaction if a widget includes any setTimeout functions.

$(function(){

  // initialize the tablesorter plugin
  $('table')
    .tablesorter()
    // bind to sort events

    .bind('tablesorter-ready', function(e, table) {
      // do something after tablesorter has finished interacting with the table;
    });

});

Use it as follows:

$(function(){

  // initialize the tablesorter plugin
  $('table')
    .tablesorter()
    // bind to sort events
    .bind('refreshComplete', function(e, table) {
      // do something after the 'refreshWidgets' has refreshed
    });

});

You can use this event to modify the filter elements (row, inputs and/or selects) as desired. Use it as follows:

$(function(){
  $('table')

    // bind to filter initialized event BEFORE initializing tablesorter*
    .bind('filterInit', function(){
      $(this).find('tr.tablesorter-filter-row').addClass('fred');
    })

     // initialize the sorter
    .tablesorter({
      widgets : ['filter']
    });

});

* Note: bind to all initialization events before initializing tablesorter; because most of the time, if bound after, the events will fire before the binding occurs.

You can use this event to do something like add a class to the filter row. Use it as follows:

$(function(){
  $('table').bind('filterStart', function(){
    $(this).find('tr.tablesorter-filter-row').addClass('filtering');
  });
});

You can use this event to do something like remove the class added to the filter row when the filtering started. Use it as follows:

$(function(){
  $('table').bind('filterEnd', function(event, config){
    $(this).find('tr.tablesorter-filter-row').removeClass('filtering');
  });
});

You can use this event to do something like modify content within the sticky header:

$(function(){
  $('table')
    // bind to the init event BEFORE initializing tablesorter*
    .bind('stickyHeadersInit', function(){
      // this.config.widgetOptions.$sticky contains the entire sticky header table
      this.config.widgetOptions.$sticky.find('tr.tablesorter-headerRow').addClass('sticky-styling');
    })

  // initialize the tablesorter plugin
  .tablesorter({
    widgets : ['stickyHeaders']
  });

});

* Note: bind to all initialization events before initializing tablesorter; because most of the time, if bound after, the events will fire before the binding occurs.

$(function(){

  // initialize the sorter
  $("table")
    .tablesorter()

    // initialize the pager plugin
    .tablesorterPager({
      container: $("#pager")
    })

    // bind to pager events
    .bind('pagerChange pagerComplete', function(event, options){
      // options = table.config.pager (pager addon)
      // options = table.config (pager widget) - so use options.pager.page below
      // c.totalPages contains the total number of pages
      $('#display').html( event.type + " event triggered, now on page " + (options.page + 1) );
    });

});

Note In v2.18.1, the "pagerComplete" event also fires off immediately after pager initialization.

$(function(){

  // initialize the sorter
  $("table")
    .tablesorter()

    // initialize the pager plugin
    .tablesorterPager({
      container: $("#pager")
    })

    // bind to pager events
    .bind('pagerChange pagerComplete', function(event, options){
      // options = table.config.pager (pager addon)
      // options = table.config (pager widget) - so use options.pager.page below
      // c.totalPages contains the total number of pages
      $('#display').html( event.type + " event triggered, now on page " + (options.page + 1) );
    });

});

$(function(){

  $("table")

    // bind to pager initialized event BEFORE calling the ADDON
    // or BEFORE initializing tablesorter when using the pager WIDGET*
    .bind('pagerBeforeInitialized', function(event, options){
      // options = table.config.pager (pager addon)
      // options = table.config (pager widget)

      // event = event object; options = pager options
    })

    // initialize the sorter
    .tablesorter()

    // initialize the pager plugin
    .tablesorterPager({
      container: $("#pager")
    });

});

* Note: bind to all initialization events before initializing tablesorter; because most of the time, if bound after, the events will fire before the binding occurs.

$(function(){

  $("table")

    // bind to pager initialized event BEFORE calling the ADDON
    // or BEFORE initializing tablesorter when using the pager WIDGET*
    .bind('pagerInitialized', function(event, options){
      // options = table.config.pager (pager addon)
      // options = table.config (pager widget) - so use options.pager.page below
      // c.totalPages contains the total number of pages
      $('#display').html( e.type + " event triggered, now on page " + (options.page + 1) );
    })

    // initialize the sorter
    .tablesorter()

    // initialize the pager plugin
    .tablesorterPager({
      container: $("#pager")
    });

});

* Note: bind to all initialization events before initializing tablesorter; because most of the time, if bound after, the events will fire before the binding occurs.

This event may fire before the pagerComplete event when ajax processing is involved, or after the pagerComplete on normal use. See issue #153.

$(function(){

  // initialize the sorter
  $("table")
    .tablesorter()

    // initialize the pager plugin
    .tablesorterPager({
      container: $("#pager")
    })

    // bind to pager events
    .bind('pageMoved', function(event, options){
      // options = table.config.pager (pager addon)
      // options = table.config (pager widget) - so use options.pager.page below
      // c.totalPages contains the total number of pages
      $('#display').html( event.type + " event triggered, now on page " + (options.page + 1) );
    });

});