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.

As of 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.

In 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}).

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 (v2.4).

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.

• "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.

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.

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.

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 column
      0: { sorter: 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 column
      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 column 9

    }
  });
});

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

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.

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(){
  $("table").tablesorter({
    headerTemplate: '{content}',
    onRenderHeader: function (){
      $(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.

sorter: false	disable sort for this column.
sorter: "text"	Sort alpha-numerically.
sorter: "digit"	Sort numerically.
sorter: "currency"	Sort by currency value (supports "£$€¤¥¢").
sorter: "ipAddress"	Sort by IP Address.
sorter: "url"	Sort by url.
sorter: "isoDate"	Sort by ISO date (YYYY-MM-DD or YYYY/MM/DD; these formats can be followed by a time).
sorter: "percent"	Sort by percent.
sorter: "usLongDate"	Sort by date (U.S. Standard, e.g. Jan 18, 2001 9:12 AM or 18 Jan 2001 9:12 AM (new in v2.7.4)).
sorter: "shortDate"	Sort by a shortened date (see dateFormat; these formats can also be followed by a time).
sorter: "time"	Sort by time (23:59 or 12:59 pm).
sorter: "metadata"	Sort by the sorter value in the metadata - requires the metadata plugin.

Check out the headers option to see how to use these parsers in your table (example #1).
Or add a header class name using "sorter-" plus the parser name (example #2), this includes custom parsers (example #3).

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

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

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.

This option can also be set using jQuery data (v2.3.1) 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.

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.

This order can also be set by desired column using the headers option (Added in 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 continuing 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.

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.

When changing this theme option, make sure that the appropriate css theme file has also been loaded. Included theme files include: see all themes

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.

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

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

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
    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 ***
      // show any column matches
      filter_anyMatch      : false,
      // Include child rows content in the search
      filter_childRows     : false,
      // show column filters
      filter_columnFilters : true,
      // 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',
      // class added to filtered rows; needed by pager plugin
      filter_filteredRow   : 'filtered',
      // add custom filter elements to the filter row
      filter_formatter     : null,
      // add custom filter functions using this option.
      filter_functions     : null,
      // 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,
      // a selector in a header with this class name will only show selected options in the drop down
      filter_onlyAvail     : 'filter-onlyAvail',
      // jQuery selector string of an element used to reset the filters.
      filter_reset         : null,
      // typing delay in milliseconds before starting a search.
      filter_searchDelay   : 300,
      // 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,

      // *** stickyHeaders widget ***
      // extra class name added to the sticky header row
      stickyHeaders : '',
      // number or jquery selector targeting the position:fixed element
      stickyHeaders_offset : 0,
      // 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

      // *** 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,

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

      // *** uitheme widget ***
      // include the name of the theme to use current options are
      // "jui" (default) and "bootstrap"
      uitheme : "jui",

      // *** zebra widget ***
      // class names to add, default is [ "even", "odd" ]
      zebra : ["ui-widget-content even", "ui-state-default odd"]

    }

  });
});

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" ] }
  });
});

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)
      ]
    }
  });
});

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
    }
  });
});

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') );

});

Use the filter_childRows option include child row text as follows:

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

Use the filter_columnFilters option as follows:

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

Changed to 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 "tablesorter-filter" 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
      filter_cssFilter : "tablesorter-filter"
    }
  });
});

A new file has been included named "jquery.tablesorter.widgets-filter-formatter.js". It includes 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 : {
          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.

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
        filter_functions: {
          // Add these options to the select dropdown (regex example)
          2 : {
            "A - D" : function(e, n, f, i) { return /^[A-D]/.test(e); },
            "E - H" : function(e, n, f, i) { return /^[E-H]/.test(e); },
            "I - L" : function(e, n, f, i) { return /^[I-L]/.test(e); },
            "M - P" : function(e, n, f, i) { return /^[M-P]/.test(e); },
            "Q - T" : function(e, n, f, i) { return /^[Q-T]/.test(e); },
            "U - X" : function(e, n, f, i) { return /^[U-X]/.test(e); },
            "Y - Z" : function(e, n, f, i) { 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
        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) { return n < 10; },
            "$10 - $100" : function(e, n, f, i) { return n >= 10 && n <=100; },
            "> $100"     : function(e, n, f, i) { 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
        filter_functions: {
          // Exact match only
          1 : function(e, n, f, i) {
            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_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 escape 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.

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.

To use this option, point to a reset button or link using a jQuery selector. 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'
    }
  });
});

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);

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
    }
  });
});

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

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 "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
    }
  });
});

// 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
}

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" ]
    }
  });
});

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 selected="selected" 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>

Add this option as follows:

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

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(ajax){
        // do something with the ajax
        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).

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(ajax){
        // do something with the ajax
        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;
      }
    });
  });
});

The ajaxObject is completely customizable, except for the `url` setting which is processed using the pager's `ajaxUrl` and `customAjaxUrl` options.

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(ajax){
        // do something with the ajax;
        return [ total_rows ];
      }
    });
  });
});

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:

// [ total_rows (number), rows (array of arrays), headers (array; optional) ]
// or [ rows, total_rows, headers ]
// or [ total_rows, $(rows) ]
// or [ total_rows ]
[
  100, // total rows
  [
    [ "row1cell1", "row1cell2", ... "row1cellN" ],
    [ "row2cell1", "row2cell2", ... "row2cellN" ],
    ...
    [ "rowNcell1", "rowNcell2", ... "rowNcellN" ]
  ],
  [ "header1", "header2", ... "headerN" ] // optional
]

Here is some example JSON (comments added, but not allowed in JSON) which is contained in the City0.json file:

{
  // total rows
  "total_rows": 80,
  // headers
  "cols" : [
    "ID", "Name", "Country Code", "District", "Population"
  ],
  // row data...
  "rows" : [{
    "ID": 1,
    "Name": "Kabul",
    "CountryCode": "AFG",
    "District": "Kabol",
    "Population": 1780000
  }, {
    // row 2, etc...
  }]
}

The above JSON is processed by the following code (this returns an array of array of table rows):

$(function(){
  $("table")
    .tablesorter()
    .tablesorterPager({
      ajaxUrl: "http://mydatabase.com?page={page}&size={size}",
      ajaxProcessing: function(data){
        if (data && data.hasOwnProperty('rows')) {
          var r, row, c, d = data.rows,
          // total number of rows (required)
          total = data.total_rows,
          // array of header names (optional)
          headers = data.cols,
          // all rows: array of arrays; each internal array has the table cell data for that row
          rows = [],
          // len should match pager set size (c.size)
          len = d.length;
          // this will depend on how the json is set up - see City0.json
          // rows
          for ( r = 0; r < len; r++ ) {
            row = []; // new row array
            // cells
            for ( c in d[r] ) {
              if (typeof(c) === "string") {
                row.push(d[r][c]); // add each table cell data to row array
              }
            }
            rows.push(row); // add new row array to rows array
          }
          return [ total, rows, headers ]; // or return [ rows, total, headers ] in v2.9+
        }
      }
    });
});

Or, in tablesorter v2.10, return a jQuery object

ajaxProcessing: function(data, table){
  if (data && data.hasOwnProperty('rows')) {
    var r, row, c, d = data.rows,
    // total number of rows (required)
    total = data.total_rows,
    // array of header names (optional)
    headers = data.headers,
    // all rows: array of arrays; each internal array has the table cell data for that row
    rows = '',
    // len should match pager set size (c.size)
    len = d.length;
    // this will depend on how the json is set up - see City0.json
    // rows
    for ( r=0; r < len; r++ ) {
      rows += '<tr class="ajax-row">'; // new row
      // cells
      for ( c in d[r] ) {
        if (typeof(c) === "string") {
          rows += '<td>' + d[r][c] + '</td>'; // add each table cell data to row
        }
      }
      rows += '</tr>'; // end new row
    }
    // don't attach the $(rows) because it's difficult to tell old from new data
    // and no need to trigger an update method, it's done internally
    return [ total, $(rows), headers ];
  }
}

Or, also in tablesorter v2.10, just build the table yourself and return the total number of rows:

ajaxProcessing: function(data, table){
  if (data && data.hasOwnProperty('rows')) {
    var r, row, c, d = data.rows,
    // total number of rows (required)
    total = data.total_rows,
    // all rows: array of arrays; each internal array has the table cell data for that row
    rows = '',
    // len should match pager set size (c.size)
    len = d.length;
    // this will depend on how the json is set up - see City0.json
    // rows
    for ( r=0; r < len; r++ ) {
      rows += '<tr class="ajax-row">'; // new row
      // cells
      for ( c in d[r] ) {
        if (typeof(c) === "string") {
          rows += '<td>' + d[r][c] + '</td>'; // add each table cell data to row
        }
      }
      rows += '</tr>'; // end new row
    }
    // find first sortable tbody, then add new rows
    table.config.$tbodies.eq(0).html(rows);
    // no need to trigger an update method, it's done internally
    return [ total ];
  }
}

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
{page}	The current pager page
{totalPages}	Total number of pager pages
{filteredPages}	Total number of pages left after being filtered
{startRow}	Starting row number currently displayed
{endRow}	Ending row number currently displayed
{filteredRows}	Total number of rows left after being filtered
{totalRows}	Total number of rows

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

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.

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.

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.

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.

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 there is no period "." in front of this class name (it is not a selector).

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