Fidelix is a light weight Linux distribution that focuses on proactive security. It aims to eliminate unnecessary code and is targeted primarily towards servers and embedded systems.
Includes these packages in the standard installation (this list is not exhaustive):
At least a minimal set of daemons will be included in the base system in the future.
Eventually, the plan is to support pkgsrc from NetBSD. This will (hopefully) provide over 22 000 packages in addition to the base system for users who require or would like additional functionality.
After working on Cucumber Linux for over three years, I began to realize that the distribution had grown too large and convoluted for such a small development team keep up with. I decided that if I had a chance to do it all over, I would place less emphasis on desktop usage and more emphasis on server/embedded usage. Additionally, I would greatly reduce the code base of the base system and opt for lighter weight packages where possible to further reduce the codebase and decrease the maintainence burden. By a work of fate, I ended up with a large amount of free time in March and April of 2020 and I decided to give these ideas a try.


What's new in beta 2
This build contains:
- New feature: a keyboard hotkey for shortening.
(Default off; default hotkey: option/alt + S) - New feature: a quick option menu. Hold on the shorten button on Safari's toolbar to display. (Safari 5.1+ only)
- Improved Italiano locale thanks to Raffaele Viggiani
- Improved Simplified Chinese locale thanks to @catjia1990
- Updating jsOAuth library to ver 1.3
- Localable strings for new features.
- Other bug fixes and enhancements
Or you can visit Gihub for commit log of v2.0 beta 2.


Even the all powering has no control about the blind texts it is an almost unorthographic life One day however small line of blind text by the name of Lorem ipsum decided toleave for the far worldd of Grammer.
"Wild Question Marks, but the Little Blind"
"Wild Question Marks, but the Little Blind"
"Wild Question Marks, but the Little Blind"
"Wild Question Marks, but the Little Blind"


palette
The overall FrontEnd Design is done in HTML CSS and JavaScript using Material Design . The powerful
features
provided by CSS and
JavaScript help in designing an interactive website.
extension
The process of linking the BackEnd with the FrontEnd is achieved by PYTHON using FLASK and JINJA2
Framework.
It is simple , clean ,
easy-to-understand and it is the best all-in-all.
dvr
The database is developed in SQLite backed up on Clever-Cloud. It is a open source Light weight
database.It's
fully-flexed and builtin support for
PYTHON makes it a hassle-free and super-easy.


This is an example page that loads strictly the minimal core styles & scripts required by CORAL and the timeline-contacts component
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Repellendus, asper


Cookies are small data files that are issued to your device when you visit a website and that store information about your use of a service. Pixel tags (which are also called clear GIFs, web beacons, or pixels) are little snippets of code or tiny images embedded on websites and in email that help us learn how you interact with our site and emails.
Kickstarter uses cookies and these other technologies to help recognize you as a repeat visitor, to improve the quality of our Services, and to make your browsing experience more meaningful.
When you visit Kickstarter, our web server sends a cookie to your device, which allows us to recognize your device (but not the specific person using it). By associating the identification numbers in the cookies with other account information when, for example, you log in to the Services, we know that the cookie information relates to your user account. Similarly, pixel tags on Kickstarter and in email communications help us identify how your device is being used to interact with Kickstarter materials. Some of the tags and cookies used by our Services are served by us, and some are served by trusted partners who are delivering services on our behalf.
Some examples of the types of cookies and other technologies Kickstarter uses:
Kickstarter uses authentication cookies and similar technologies to tell us when you’re logged in to Kickstarter. This lets us show you personalized views related to your interests and connect you with projects you may already have backed.
Cookies also help keep Kickstarter secure by enabling security features and allowing us to detect activity that might violate our rules and terms of service.
These cookies help protect your account from being accessed by anyone other than you, alert you and us when your account is accessed, and provide capabilities that allow us to disable any active sessions you have (for example, when you log out or change your password).
Some cookies help us provide localized experiences — for example, by making sure you see Kickstarter in your preferred language.
Kickstarter uses cookies that provide functionality and help us deliver our products and services — for instance, by storing your preferences or by pre-filling the username field when you log in.
Performance cookies help us route traffic between servers and understand how Kickstarter is performing, so we can provide you with the best experience possible.
Cookies and other technologies also help us to understand, improve, and research features and content on the Kickstarter site. For example, we may use cookies to understand how you are discovering projects or to determine which types of browsers or devices are accessing Kickstarter.
Most web browsers automatically accept cookies but, if you prefer, you can change your browser to prevent that or to notify you each time a cookie is set. You can also learn more about cookies by visiting www.allaboutcookies.org, which includes useful information on cookies and how to block cookies using different browsers. Blocking or deleting cookies may prevent you from taking full advantage of our Services. Since "Do Not Track" is not yet a precisely defined standard, we currently treat DNT:1 signals according to the same standards set out in our Privacy and Cookie Policies.


Welcome to the Market!
At My Market, we have the freshest produce
and the best quality groceries around.
Whether you're looking for a warm pastry from our bakery or
cake mix to make your own, we have it all!
More At My Market!
Loyalty Program
Join our loyalty program today and receive a 20% discount on your first purchase!
Coupons
Find digital coupons or see the weekly circular.
Recipes
New recipes perfect for fall!


The localeCompare()
method returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.
The new locales
and options
arguments let applications specify the language whose sort order should be used and customize the behavior of the function. In older implementations, which ignore the locales
and options
arguments, the locale and sort order used are entirely implementation dependent.
referenceStr.localeCompare(compareString[, locales[, options]])
Check the Browser compatibility section to see which browsers support the locales
and options
arguments, and the Checking for support for locales
and options
arguments for feature detection.
compareString
Returns an integer indicating whether the referenceStr comes before, after or is equivalent to the compareStr.
DO NOT rely on exact return values of -1 or 1. Negative and positive integer results vary between browsers (as well as between browser versions) because the W3C specification only mandates negative and positive values. Some browsers may return -2 or 2 or even some other negative or positive value.
localeCompare()
// The letter "a" is before "c" yeilding a negative value 'a'.localeCompare('c'); // -2 or -1 (or some other negative value) // Alphabetically the word "check" comes after "against" yeilding a positive value 'check'.localeCompare('against'); // 2 or 1 (or some other positive value) // "a" and "a" are equivalent yeilding a neutral value of zero 'a'.localeCompare('a'); // 0
The locales
and options
arguments are not supported in all browsers yet. To check whether an implementation supports them, use the "i" argument (a requirement that illegal language tags are rejected) and look for a RangeError exception:
function localeCompareSupportsLocales() { try { 'foo'.localeCompare('bar', 'i'); } catch (e) { return e.name === 'RangeError'; } return false; }
locales
The results provided by localeCompare()
vary between languages. In order to get the sort order of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales
argument:
console.log('ä'.localeCompare('z', 'de')); // a negative value: in German, ä sorts with a console.log('ä'.localeCompare('z', 'sv')); // a positive value: in Swedish, ä sorts after z
options
The results provided by localeCompare()
can be customized using the options
argument:
// in German, ä has a as the base letter console.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0 // in Swedish, ä and a are separate base letters console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // a positive value
When comparing large numbers of strings, such as in sorting large arrays, it is better to create an Intl.Collator object and use the function provided by its compare property.
Created by Mozilla Contributors, license: CC-BY-SA 2.5


Provides a set of fonts with permissive licences. This is useful when you want to avoid system fonts to make sure your outputs are reproducible.
| Version: | 0.2.1 |
| Depends: | R (≥ 3.0.0) |
| Imports: | fontBitstreamVera (≥ 0.1.0), fontLiberation (≥ 0.1.0) |
| Suggests: | testthat, htmltools |
| Published: | 2017-02-01 |
| Author: | Lionel Henry [cre, aut], RStudio [cph], George Douros [cph] (Symbola font) |
| Maintainer: | Lionel Henry <lionel at rstudio.com> |
| License: | GPL-3 | file LICENSE |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | fontquiver results |
| Reference manual: | fontquiver.pdf |
| Package source: | fontquiver_0.2.1.tar.gz |
| Windows binaries: | r-devel: fontquiver_0.2.1.zip, r-release: fontquiver_0.2.1.zip, r-oldrel: fontquiver_0.2.1.zip |
| OS X binaries: | r-release: fontquiver_0.2.1.tgz, r-oldrel: fontquiver_0.2.1.tgz |
| Old sources: | fontquiver archive |
| Reverse imports: | freetypeharfbuzz, vdiffr |
| Reverse suggests: | gdtools, ggExtra, svglite |
Please use the canonical form https://CRAN.R-project.org/package=fontquiver to link to this page.


--- ---
The current StateObject
This is a passthrough through to UIRouterGlobals.$current
The current StateDeclaration
This is a passthrough through to UIRouterGlobals.current
The latest successful state parameters
This is a passthrough through to UIRouterGlobals.params
The Transition currently in progress (or null)
This is a passthrough through to UIRouterGlobals.transition
Handler for when transitionTo is called with an invalid state.
Handler for when transitionTo is called with an invalid state.
Invokes the onInvalid callbacks, in natural order. Each callback's return value is checked in sequence until one of them returns an instance of TargetState. The results of the callbacks are wrapped in $q.when(), so the callbacks may return promises.
If a callback returns an TargetState, then it is used as arguments to $state.transitionTo() and the result returned.
Sets or gets the default transitionTo error handler.
Sets or gets the default transitionTo error handler.
The error handler is called when a Transition is rejected or when any error occurred during the Transition. This includes errors caused by resolves and transition hooks.
Note: This handler does not receive certain Transition rejections. Redirected and Ignored Transitions are not considered to be errors by StateService.transitionTo.
The built-in default error handler logs the error to the console.
You can provide your own custom handler.
stateService.defaultErrorHandler(function() {
// Do not log transitionTo errors
});
a global error handler function
the current global error handler
Gets a registered StateDeclaration object
Gets a registered StateDeclaration object
Returns the state declaration object for any specific state, or for all registered states.
(absolute or relative) If provided, will only get the declaration object for the requested state. If not provided, returns an array of ALL states.
When stateOrName
is a relative state reference (such as .bar.baz
), the state will be retrieved relative to this state.
a StateDeclaration object (or array of all registered StateDeclaration objects.)
Transition to a different state and/or parameters
Transition to a different state and/or parameters
Convenience method for transitioning to a new state.
$state.go
calls $state.transitionTo
internally but automatically sets options to
{ location: true, inherit: true, relative: router.globals.$current, notify: true }
.
This allows you to use either an absolute or relative to
argument (because of relative: router.globals.$current
).
It also allows you to specify * only the parameters you'd like to update, while letting unspecified parameters
inherit from the current parameter values (because of inherit: true
).
let app = angular.module('app', ['ui.router']);
app.controller('ctrl', function ($scope, $state) {
$scope.changeState = function () {
$state.go('contact.detail');
};
});
Absolute state name, state object, or relative state path (relative to current state).
Some examples:
$state.go('contact.detail')
- will go to the contact.detail
state$state.go('^')
- will go to the parent state$state.go('^.sibling')
- if current state is home.child
, will go to the home.sibling
state$state.go('.child.grandchild')
- if current state is home, will go to the home.child.grandchild
stateA map of the parameters that will be sent to the state, will populate $stateParams.
Any parameters that are not specified will be inherited from current parameter values (because of inherit: true
).
This allows, for example, going to a sibling state that shares parameters defined by a parent state.
Transition options
A promise representing the state of the new transition.
Generates a URL for a state and parameters
Generates a URL for a state and parameters
Returns the url for the given state populated with the given params.
expect($state.href("about.person", { person: "bob" })).toEqual("/about/bob");
The state name or state object you'd like to generate a url from.
An object of parameter values to fill the state's required parameters.
Options object. The options are:
compiled state url
Checks if the current state includes the provided state
Checks if the current state includes the provided state
A method to determine if the current active state is equal to or is the child of the state stateName. If any params are passed then they will be tested for a match as well. Not all the parameters need to be passed, just the ones you'd like to test for equality.
$state.$current.name === 'contacts.details.item'
// Using partial names
$state.includes("contacts"); // returns true
$state.includes("contacts.details"); // returns true
$state.includes("contacts.details.item"); // returns true
$state.includes("contacts.list"); // returns false
$state.includes("about"); // returns false
* $state.$current.name === 'contacts.details.item.url'
:$state.includes("*.details.*.*"); // returns true
$state.includes("*.details.**"); // returns true
$state.includes("**.item.**"); // returns true
$state.includes("*.details.item.url"); // returns true
$state.includes("*.details.*.url"); // returns true
$state.includes("*.details.*"); // returns false
$state.includes("item.**"); // returns false
A partial name, relative name, glob pattern, or state object to be searched for within the current state name.
A param object, e.g. {sectionId: section.id}
,
that you'd like to test against the current active state.
An options object. The options are:
relative
: If stateOrName
is a relative state name and options.relative
is set, .is will
test relative to options.relative
state (or name).Returns true if it does include the state
Checks if the current state is the provided state
Checks if the current state is the provided state
Similar to includes but only checks for the full state name. If params is supplied then it will be tested for strict equality against the current active params object, so all params must match with none missing and no extras.
$state.$current.name = 'contacts.details.item';
// absolute name
$state.is('contact.details.item'); // returns true
$state.is(contactDetailItemStateObject); // returns true
// relative name (. and ^), typically from a template // E.g. from the 'contacts.details' template

Item

The state name (absolute or relative) or state object you'd like to check.
A param object, e.g. {sectionId: section.id}
, that you'd like
to test against the current active state.
An options object. The options are:
relative
: If stateOrName
is a relative state name and options.relative
is set, .is will
test relative to options.relative
state (or name).Returns true if it is the state.
Lazy loads a state
Lazy loads a state
Explicitly runs a state's StateDeclaration.lazyLoad function.
the state that should be lazy loaded
the optional Transition context to use (if the lazyLoad function requires an injector, etc) Note: If no transition is provided, a noop transition is created using the from the current state to the current state. This noop transition is not actually run.
a promise to lazy load
Registers an Invalid State handler
Registers an Invalid State handler
Registers a OnInvalidCallback function to be invoked when StateService.transitionTo has been called with an invalid state reference parameter
Example:
stateService.onInvalid(function(to, from, injector) {
if (to.name() === 'foo') {
let lazyLoader = injector.get('LazyLoadService');
return lazyLoader.load('foo')
.then(() => stateService.target('foo'));
}
});
invoked when the toState is invalid This function receives the (invalid) toState, the fromState, and an injector. The function may optionally return a TargetState or a Promise for a TargetState. If one is returned, it is treated as a redirect.
a function which deregisters the callback
Reloads the current state
Reloads the current state
A method that force reloads the current state, or a partial state hierarchy. All resolves are re-resolved, and components reinstantiated.
let app angular.module('app', ['ui.router']);
app.controller('ctrl', function ($scope, $state) {
$scope.reload = function(){
$state.reload();
}
});
Note: reload()
is just an alias for:
$state.transitionTo($state.current, $state.params, {
reload: true, inherit: false
});
A state name or a state object. If present, this state and all its children will be reloaded, but ancestors will not reload.
//assuming app application consists of 3 states: 'contacts', 'contacts.detail', 'contacts.detail.item'
//and current state is 'contacts.detail.item'
let app angular.module('app', ['ui.router']);
app.controller('ctrl', function ($scope, $state) {
$scope.reload = function(){
//will reload 'contact.detail' and nested 'contact.detail.item' states
$state.reload('contact.detail');
}
});
A promise representing the state of the new transition. See StateService.go
Creates a TargetState
Creates a TargetState
This is a factory method for creating a TargetState
This may be returned from a Transition Hook to redirect a transition, for example.
Low-level method for transitioning to a new state.
Low-level method for transitioning to a new state.
The go method (which uses transitionTo
internally) is recommended in most situations.
let app = angular.module('app', ['ui.router']);
app.controller('ctrl', function ($scope, $state) {
$scope.changeState = function () {
$state.transitionTo('contact.detail');
};
});
State name or state object.
A map of the parameters that will be sent to the state, will populate $stateParams.
Transition options
A promise representing the state of the new transition. See go
Generated using TypeDoc
Provides state related service functions
This class provides services related to ui-router states. An instance of this class is located on the global UIRouter object.


Temperature may plunge to 13°C as cold wave grips Karachi
by Our CorrespondentKARACHI: Temperature is expected to drop to 13 degrees Celsius to 15 degrees Celsius on Saturday after a cold spell hit Karachi, as well as other areas of Sindh.
The mercury drastically fell by eight degrees to 15 degrees Celsius in the port city on Friday, according to the Pakistan Meteorological Department (PMD).
Chief Meteorologist Sardar Sarfaraz said the recent drop in temperature in the city has broken the previous record of average minimum temperature recorded in Karachi in November, which is 16 degrees Celsius. He attributed the sudden fall in temperature to the drop in temperatures in Quetta and Qalat, a system of cold wind entering the country and recent spells of rainfall in northern areas and Islamabad. Sarfaraz said that the cold spell will last over the next few days.
According to the Met Office, minimum temperature ever recorded in Karachi, during the month of November, was in 1986, when the temperature dropped to 7.8 degrees Celsius.
Maximum temperature in Karachi on Friday was recorded at 29.5 degrees Celsius and humidity levels reduced to 20%. Northwestern winds blew all day long while the visibility was reduced in the morning due to fog.
In other Sindh towns and cities, minimum temperature of 10 degrees Celsius was recorded in Mohenjo Daro, 12 degrees Celsius in Sakrand, 12.5 degrees Celsius in Sukkur, 13 degrees Celsius in Tando Jam and Mithi, 13.7 degrees Celsius in Chor, 14.5 degrees Celsius in Rohri and Dadu, 15 degrees Celsius in Jacobabad, 16.5 degrees Celsius in Thatta, Mirpurkhas and Badin, 17 degrees Celsius in Hyderabad and 18 degrees Celsius in Nawabshah.


P.S:- "mqtt://" protocol is not supported by this plugin. Instead use "tcp://" which works with any broker.


get-going-nzcensr.Rmd
The nzcensr
package is a data package which makes it easy to import the New Zealand Census data as either normal or spatial dataframes without having to download the data for each project and perform different joins. The package contains the following data sets:
All of these data sets are provided at the meshblock, area unit, local board, territorial authority (“tas”) and regional spatial level. They all follow the same regular naming convention of data set name with the spatial area following e.g.
dwelling_area_units
or
individual_part_3b
All of the data sets are lazily loaded which means that they are only brought into memory when called; not when the package is just loaded.
A key idea behind this package is the idea of making it easier to access and know what data is available and then to transform it. The function nz_census_tables
makes it easy to explore the data. Simply calling it without any arguments returns a table with all of the data frames available, and a small note explaining what they are:
kable(nz_census_tables())
| dataset | description |
|---|---|
| dwelling_area_units | Dwelling data set at the area unit level |
| dwelling_local_boards | Dwelling data set at the local board level |
| dwelling_meshblocks | Dwelling data set at the meshblock level |
| dwelling_regions | Dwelling data set at the regional level |
| dwelling_tas | Dwelling data set at the territorial authority level |
| family_area_units | Family data set at the area unit level |
| family_local_boards | Family data set at the local board level |
| family_meshblocks | Family data set at the meshblock level |
| family_regions | Family data set at the regional level |
| family_tas | Family data set at the territorial authority level |
| household_area_units | Household data set at the area unit level |
| household_local_boards | Household data set at the local board level |
| household_meshblocks | Household data set at the meshblock level |
| household_regions | Household data set at the regional level |
| household_tas | Household data set at the territorial authority level |
| individual_part_1_area_units | Individual (Part 1) data set at the area unit level |
| individual_part_1_local_boards | Individual (Part 1) data set at the local board level |
| individual_part_1_meshblocks | Individual (Part 1) data set at the meshblock level |
| individual_part_1_regions | Individual (Part 1) data set at the regional level |
| individual_part_1_tas | Individual (Part 1) data set at the territorial authority level |
| individual_part_2_area_units | Individual (Part 2) data set at the area unit level |
| individual_part_2_local_boards | Individual (Part 2) data set at the local board level |
| individual_part_2_meshblocks | Individual (Part 2) data set at the meshblock level |
| individual_part_2_regions | Individual (Part 2) data set at the regional level |
| individual_part_2_tas | Individual (Part 2) data set at the territorial authority level |
| individual_part_3a_area_units | Individual (Part 3A) data set at the area unit level |
| individual_part_3a_local_boards | Individual (Part 3A) data set at the local board level |
| individual_part_3a_meshblocks | Individual (Part 3A) data set at the meshblock level |
| individual_part_3a_regions | Individual (Part 3A) data set at the regional level |
| individual_part_3a_tas | Individual (Part 3A) data set at the territorial authority level |
| individual_part_3b_area_units | Individual (Part 3B) data set at the area unit level |
| individual_part_3b_local_boards | Individual (Part 3B) data set at the local board level |
| individual_part_3b_meshblocks | Individual (Part 3B) data set at the meshblock level |
| individual_part_3b_regions | Individual (Part 3B) data set at the regional level |
| individual_part_3b_tas | Individual (Part 3B) data set at the territorial authority level |
This function also accepts the input of a table which returns all of the unique topics in the data set, and whether to include the variables or not.
kable(nz_census_tables(dwelling_area_units))
| topics |
|---|
| dwelling_record_type_for_occupied_dwellings |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings |
| number_of_bedrooms_for_occupied_private_dwellings |
| number_of_rooms_for_occupied_private_dwellings |
| occupied_private_dwelling_type |
or (table shows just the first ten for presentation)
nz_census_tables(dwelling_area_units, variables = TRUE) %>%
slice(1:10) %>%
kable()
| topic | variable |
|---|---|
| dwelling_record_type_for_occupied_dwellings | Occupied Non-private Dwelling |
| dwelling_record_type_for_occupied_dwellings | Occupied Private Dwelling |
| dwelling_record_type_for_occupied_dwellings | Total occupied dwellings |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings | Bottled Gas |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings | Coal |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings | Electricity |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings | Mains Gas |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings | No Fuels Used in this Dwelling |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings | Not Elsewhere Included(5) |
| fuel_types_used_to_heat_dwellings_(total_responses)(4)_for_occupied_private_dwellings | Other Fuel(s) |
Let’s have a look at religious association in Auckland, New Zealand. Firstly, let’s select the topic using the keyword religion, and then transform into the long format that is ‘cleaned’ and replace the confidential values with 1. By cleaned, I mean that the census columns are split up into year, topic and variable columns.
religious_association_nz_region <-
select_by_topic(individual_part_2_regions, "religious") %>%
filter_by_area("regions", "regions", "Auckland") %>%
transform_census(include_gis = FALSE, long = TRUE,
clean = TRUE, replace_confidential_values = 1)
The above workflow essentially encapsulates the workflow brought to the user by the nzcensr
package which tries to make it as easy to access the data, select the topics wanted, filter by regions and transform in a ‘tidy’ table. The output of this is the following table (top five rows only):
| Area_Code_and_Description | Code | Description | year | topic | variable | value |
|---|---|---|---|---|---|---|
| 02 Auckland Region | 02 | Auckland Region | 2001 | religious affiliation (total responses)(2) for the census usually resident population count(1) | Buddhist | 22722 |
| 02 Auckland Region | 02 | Auckland Region | 2001 | religious affiliation (total responses)(2) for the census usually resident population count(1) | Christian | 604713 |
| 02 Auckland Region | 02 | Auckland Region | 2001 | religious affiliation (total responses)(2) for the census usually resident population count(1) | Hindu | 25788 |
| 02 Auckland Region | 02 | Auckland Region | 2001 | religious affiliation (total responses)(2) for the census usually resident population count(1) | Islam/Muslim | 15318 |
| 02 Auckland Region | 02 | Auckland Region | 2001 | religious affiliation (total responses)(2) for the census usually resident population count(1) | Judaism/ Jewish | 3132 |
Cool, that is all tidy.
Let’s make some plots!
 To do this, we create two tables of the religions and the totals and then join them back to each other based on the region. Then we can simply divide the religion number by the total and create a percentage.
religious_association_nz_region_wanted_variables <-
filter(religious_association_nz_region,
!(variable %in% c("Not Elsewhere Included(3)",
"Total people",
"Total people stated",
"Object to Answering",
"Other Religions",
"Spiritualism and New Age Religions"))) %>%
rename(number_people = value)
religious_association_nz_region_total_stated <- religious_association_nz_region %>%
filter(variable == "Total people stated") %>%
select(Area_Code_and_Description, year, total_number_people = value)
religious_association_nz_region_percent <-
left_join(religious_association_nz_region_wanted_variables,
religious_association_nz_region_total_stated) %>%
mutate(percentage_people = round(number_people / total_number_people, 4) * 100,
Description = str_replace(Description, " Region", "")) %>%
select(-topic)
#> Joining, by = c("Area_Code_and_Description", "year")
Now to create a line plot to investigate the trends the three time periods.
ggplot(religious_association_nz_region_percent) +
geom_line(aes(x = year, y = percentage_people, colour = variable, group = variable)) +
scale_colour_discrete(name = "Religion") +
ggtitle("Religion as a percentage of population in Auckland from\n2001 to 2006 to 2013") +
ylab("Percent") +
xlab("Year") +
theme_minimal() +
theme(legend.position = "top")
Interesting, in these plots you can clearly see the ‘decline’ of Christianity occuring and the increasing ‘lack of religion’. Clearly, these two categories dwarf the others, and it would be interesting to drop these out to see more of the minor religions.
religious_association_nz_region_percent_minors <-
filter(religious_association_nz_region_percent,
!(variable %in% c("Christian", "No Religion")))
ggplot(religious_association_nz_region_percent_minors) +
geom_line(aes(x = year, y = percentage_people, colour = variable, group = variable)) +
facet_wrap(~Description, scales = "free_y") +
scale_colour_discrete(name = "Religion") +
ggtitle("Religion as a percentage of population in Auckland from\n2001 to 2006 to 2013") +
ylab("Percent") +
xlab("Year") +
theme_minimal() +
theme(legend.position = "top")
Some interesting things going on here! Anyway, I hope I have demonstrated how easy it is to analyse NZ census data with the nzcensr
package. It’s brand new, and my first package, so please let me know if you find any issues or bugs.


Written by Ivi Apostolatos
Graphic Design Bachelors Thesis
Graduating Class of 2021
Royal Academy of Art, The Hague


Hosts are detected when you accept a node or create a cluster
If you have already cluster created and still do not see hosts, make sure the hosts are configured correctly.


Bases: matplotlib.ticker.MaxNLocator
compute an n period moving average. type is ‘simple’ | ‘exponential’
return value is emaslow, emafast, macd which are len(x) arrays
compute the n period relative strength indicator http://stockcharts.com/school/doku.php?id=chart_school:glossary_r#relativestrengthindex http://www.investopedia.com/terms/r/rsi.asp


{% extends "base.html" %} {% block title %}
Medieval catalogues > SECULAR INSTITUTIONS: Secular Colleges > Southwell, Minster > Inventory of goods at the parish altar, 6 August 1369
{% endif %}3 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


Opening Remarks
Transcript By: Bryan Bishop
Tags: Research
Category: Workshop
Opening remarks
Shin’ichiro Matsuo
http://bsafe.network/events/codefi_stanford_2020/
https://diyhpl.us/wiki/transcripts/coordination-of-decentralized-finance-workshop/2020-stanford/
https://twitter.com/kanzure/status/1229833591716102144
Good morning. Let us start this workshop. I am a researcher at Georgetown University and it is my pleasure to host this workshop. CoDeFi is a workshop about coordination of decentralized finance. This unfortunately shares a name with a Consensys product. CoDeFi contains CoDe and DeFi. This is a multi-stakeholder workshop to discuss stakeholders that have never met before. I think we have regulators here, and engineers here, and researchers here, and business people here. There are many consortiums in the blockchain world, but most of them do not have the participation of engineers. This is a historical moment to get all stakeholders in one place.
This figure in this slide shows a few of the different stakeholders. We have regulators, open-source style engineers, business stakeholders, and consumers. The consumers are primarily interacting through the businesses, and the businesses interact with regulators and open-source engineers. Regulators have few connections to open-source engineers or the cypherpunks. It’s very hard to regulate open-source software at this time. The business entities would like to start businesses before mastering technology, and they would like to avoid friction with regulators. Consumers need transparency with business, based on the blockchain. As you remember, most ICO projects have 2-3 page whitepaper so that it looks useful to consumers. It’s important to have transparency of the business.
This is a background for why he are holding the CoDeFi workshop. Last year, Japan was the host country for G20 on June 8-9th, 2019 in Fukuoaka. On June 6th, 2019 there was a report by the Financial Stability Board (FSB). This report considered the impact of distributed ledger technologies and p2p on financial stability, regulation and governance implications. This report set out the benefits and risks of increased use of decentralized finance. This report underscored the importance of multi-stakeholder dialogue.
Here are two paragraphs of this effort.
After the G20 meeting, there was another meeting: a G20 high-level siminar on financial innovation “Our future in the digital age”. It was with Jun Marai, Klaas Knot, Adam Back, Shinichiro Matsuo, and Brad Carr. Jun Murai was an early internet pioneer and he was a moderator of the panel. Klaas Knot was a president of the Dutch national bank and provided a view of regulators. Adam Back is a cypherpunk and open-source engineer. I represented the perspective of academia and researchers.
This is a sentence from the comminique of G20: “We also welcome the FSB report on decentralized financial technologies, and the possible implications for financial stability, regulation and governance, and how regulators can enhance the dialogue with a wider group of stakeholders”. This is in the 13th paragraph of the report.
These workshops
After the G20 meeting, we had our first workshop in Vancouver and then we had one in Tokyo, Tel Aviv, London, Dublin, and we had one in Malaysia recently. Next will be Feb 26 in New York, and BG2C in Tokyo in March 9-10, and Washington in March 11, and then another one is scheduled too.
G20 meets G20 in Vancouver
There were 24 participants, including 3 regulators and 5 engineers. The topics included consumer protection and challenges of entrepreneurs to build businesses involving blockchain tech while facing uncertainty in regulations and banking.
Panel discussion at Fin/sum 2019
We had a good disucssion in Tokyo at Fin/sum 2019. This included Mai Santamaria, Allen Piscitello, Akhiko Yoshida, Shigeya Suzuki, and Shinichero Matsuo as moderator.
Decentralized Finance Architecture Workshop in Tel Aviv 2019
Scaling Bitcoin was going on at the same time as this workshop. Scaling Bitcoin is a conference for discussing development of bitcoin scaling technologies. This was handled in Tel Aviv. We had 54 participants attending this workshop, including regulators from Israel and the JFSA.
Transcripts: https://diyhpl.us/wiki/transcripts/bitcoinedge/decentralized-financial-architecture-workshop/
OECD Global Blockchain Policy Forum (September 13, 2019)
We also had a policy forum.
Goals of CoDeFi Stanford 2020
We are reusing some of the slides from the Financial Crypto (FC) conference. Stanford has a good handle on research into cryptography, economics and blockchain. We have the benefit of Stanford here today. We would like to have a common understanding among different stakeholders. We would like to produce some output paper from these discussions. All stakeholders should be included, and it will be publsihed as a workshop proceeding (LNCS) as a workshop report. Papers of morning lectures should also be included.
Today’s program
The schedule is available on the website: http://bsafe.network/events/codefi_stanford_2020/
Between the presentations, we have an unconference style discussion to discuss about some of the topics we have just seen. We will choose the topics at the beginning of each unconference discussion. I am sure you know how unconference roundtables are organized. We will first pick a discussion topic, and then we elect a discussion leader for each topic and have a discussion. I think 40 minute discussion for each topic makes sense. The nwe come together as a group and share the discussion and its results to all workshop participants.
Enjoy the productive discussions today. Thank you!
See also
https://www.coindesk.com/bridging-the-gap-between-bitcoin-and-global-regulators
Unconference discussions
- Nature of systemic risk in decentralized systems
- 2020 Scaling cryptocurrency and regulatory challenges
- Common understandings on “Regulatory Goals”
- Risk and resilience in cryptocurrency financial systems
- Financial stability impacts of decentralized risk-taking, decision-making & record-keeping
- Central Bank Digital Currencies (CBDCs)
- Interoperability with existing financial infrastructure, permissionless ledgers & CBDCs
- Standards: technical, regulatory
- Governance of protocols, implementations
- Security, standards, and regulation of cryptocurrency exchanges
- FATF: AML and privacy
- Synthetic Hegemonic Currencies (SHC)
- Corporate Coins & Consortiums: Libra Coin & Association, Binance Venus, Walmart, etc.
- Mainstream adoption of cryptocurrencies & blockchain technologies
Proposed topics:
- Communicating with regulators
- Stress testing
These transcripts are sponsored by Blockchain Commons.
Tweet: Transcript: “Opening remarks” https://diyhpl.us/wiki/transcripts/coordination-of-decentralized-finance-workshop/2020-stanford/opening-remarks/ @BSafe_network @ShaneMatsuo @byrongibson @CBRStanford #SBC20


'Looney Lyrics' and silly songs abound in Regina Lyric Singers' upcoming show
The Regina Lyrics Singers perform Looney Lyrics: Comical and Novelty Songs From Broadway and Pop on Nov. 29 and 30 at MacKenzie Art Gallery.
by Ashley MartinThe Regina Lyrics Singers are getting “Looney” with their upcoming concert. With that in mind, a few of the singers reflected on their favourite funny tunes, which you can hear on Nov. 29 and 30 during Looney Lyrics: Comical and Novelty Songs From Broadway and Pop.
‘Laughing Matters’ from When Pigs Fly (1996)
Jane Ursan, artistic director, conductor, and founder of the Lyric Singers in 2012
“My favourite song is ‘Laughing Matters,’ which is about why I chose humour as the concert’s theme.” (The song begins, “Live at five and CNN keep us all abreast / Of breaking stories that can tend to make us anxious and depressed.”)
Stephanie Streifel
“Over 20 years later, the message of ‘human spirits need to be leavened by a little levity’ seems more important than ever.”
Laurie Fisher
“Its lyrics remind us that we mustn’t lose our humour despite all the chaos, malady and discontent around us — a message that’s certainly applicable in current times.”
‘The Fox (What Does the Fox Say?)’ by Norwegian comedy duo Ylvis (2013)
Rick Kotowich
“My favourite lyrics are the startling ‘Ring-ding-ding-ding-dingeringeding!’ and other mad sounds in ‘The Fox’ song, even though they are so absolutely full-on and challenging to do.”
Linda Selinger
“Lyrics are funny yet nostalgic in parts.”
‘Poisoning Pigeons in the Park’ by Tom Lehrer (1959)
Ben Redant
“It starts out very innocent and innocuous, until it takes this very dark turn, hinted at in the song’s title. Tom Lehrer is a songwriter and satirist par excellence, and having a chance to sing one of his songs for Lyric is a lot of fun.”
Sabrina Cataldo
“‘All the world seems in tune on a spring afternoon, when we’re poisoning pigeons in the park.’ … It starts out as a lovely, romantic song about spring, and then it throws you this twist that is completely unexpected and absurd. I know I will not be able to keep it together while this duet is being performed. Fortunately, we’re encouraged to laugh and respond to the songs on stage.”
‘Chili Con Carne’ by The Real Group (1989)
Angela Willford
“(It’s) basically a recipe made into a song. It is fun to sing and I love the Latin feel of it.”
Sarah Gaudet
“At first, I hated it! It was very overwhelming. It’s fast and repeats the words ‘chili con carne’ a lot, but in slightly different rhythms. At first glance, it felt impossible. But as I practised, the patterns became more obvious and the rhythms do make sense. Now it’s fun and I can’t help but shake my hips with the beat!
“I really do think the collection of songs for this show is fun. A lot of thought went into each piece, and — without spoiling the ending — there’s a message to the audience that I think is very timely.”
Jan Besse
“I love the syncopated, Latin-like rhythms and lyrics, some of which are pretty looney.”
“Alto’s Lament” by Marcy Heisler and Zina Goldrich (1995)
Jade Gritzfeld
“I remember in one choir, through the whole J.S. Bach piece, the altos sang only G for almost the entire piece, straying to an F and E when the music got really exciting. If we got an equal chance at melody or more exciting harmonies, this piece wouldn’t be so funny.”
“Nobody Makes A Pass At Me,” recorded in 1962 by Barbra Streisand
Adriana (Christianson) Putz
“My favourite lyric from a song this year is ‘Oh dear, what can the matter be?’  It’s from my first solo song called ‘Nobody Makes A Pass At Me.’ The character I play is quite over-the-top ridiculous and a very awkward flirt, which has been fun to play because it’s exercising my rusty comic acting skills.”
The Lyric Singers perform Looney Lyrics: Comical and Novelty Songs from Broadway and Pop on Friday, Nov. 29 and Saturday, Nov. 30, 7:30 p.m. at the MacKenzie Art Gallery’s Shumiatcher Theatre. Tickets are $25 and available through reginalyric.com, in person at Dancer’s Den (1630 Albert St.), and at the door.


Class: ActiveRecord::Reflection::BelongsToReflection
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
|
|
|
Instance Chain:
|
|
| Inherits: |
ActiveRecord::Reflection::AssociationReflection
|
| Defined in: | activerecord/lib/active_record/reflection.rb |
Constant Summary
Class Method Summary
Instance Attribute Summary
- #belongs_to? ⇒ Boolean readonly
AssociationReflection - Inherited
| #parent_reflection | |
| #belongs_to? | Returns |
| #collection? | Returns whether or not this association reflection is for a collection association. |
| #constructable?, #foreign_type, #has_inverse?, | |
| #has_one? | Returns |
| #has_scope?, #nested?, #polymorphic?, #type, | |
| #validate? | Returns whether or not the association should be validated as part of the parent's validation. |
MacroReflection - Inherited
| #active_record, | |
| #name | Returns the name of the macro. |
| #options | Returns the hash of options used for the macro. |
| #scope, #autosave=, #plural_name |
AbstractReflection - Inherited
| #counter_must_be_updated_by_has_many?, | |
| #has_cached_counter? | Returns whether a counter cache should be used for this association. |
| #inverse_updates_counter_cache? | |
| #inverse_updates_counter_in_memory?, #through_reflection? |
Instance Method Summary
- #association_class
- #join_id_for(owner)
- #macro
- #calculate_constructable(macro, options) private
- #join_fk private
- #join_pk(klass) private
AssociationReflection - Inherited
| #active_record_primary_key, #add_as_polymorphic_through, #add_as_source, #add_as_through, #association_class, #association_foreign_key, | |
| #association_primary_key | klass option is necessary to support loading polymorphic associations. |
| #association_primary_key_type, #association_scope_cache, | |
| #check_eager_loadable! | Alias for AssociationReflection#check_preloadable!. |
| #check_preloadable!, #check_validity!, | |
| #clear_association_scope_cache | This is for clearing cache on the reflection. |
| #collect_join_chain | A chain of reflections from this one back to the owner. |
| #compute_class, #foreign_key, #join_id_for, #join_table, | |
| #klass | Returns the target association's class. |
| #macro | Returns the macro type. |
| #polymorphic_inverse_of, #source_reflection, #through_reflection, | |
| #actual_source_reflection | FIXME: this is a horrible name. |
| #automatic_inverse_of | returns either false or the inverse association name that it finds. |
| #calculate_constructable, | |
| #can_find_inverse_of_automatically? | Checks to see if the reflection doesn't have any options that prevent us from being able to guess the inverse automatically. |
| #derive_class_name, #derive_foreign_key, #derive_join_table, | |
| #inverse_name | Attempts to find the inverse association name automatically. |
| #primary_key, | |
| #valid_inverse_reflection? | Checks if the inverse reflection that is returned from the
|
MacroReflection - Inherited
| #== | Returns |
| #compute_class, | |
| #klass | Returns the class for the macro. |
| #scope_for, #derive_class_name |
AbstractReflection - Inherited
| #alias_candidate, | |
| #build_association | Returns a new, unsaved instance of the associated class. |
| #chain, #check_validity_of_inverse!, | |
| #class_name | Returns the class name for the macro. |
| #constraints, #counter_cache_column, #get_join_keys, #inverse_of, | |
| #inverse_which_updates_counter_cache | This shit is nasty. |
| #join_keys, #join_scopes, #klass_join_scope, #primary_key_type, #quoted_table_name, #scope_chain, | |
| #scopes | Returns a list of scopes that should be applied for this ::ActiveRecord::Reflection object when querying the database. |
| #table_name, #join_fk, #join_pk |
Constructor Details
This class inherits a constructor from ActiveRecord::Reflection::AssociationReflection
Instance Attribute Details
#belongs_to? ⇒ Boolean
(readonly)
[ GitHub ]
718
# File 'activerecord/lib/active_record/reflection.rb', line 718
def belongs_to?; true; end
Instance Method Details
#association_class
[ GitHub ]720 721 722 723 724 725 726
# File 'activerecord/lib/active_record/reflection.rb', line 720
def association_class if polymorphic? Associations::BelongsToPolymorphicAssociation else Associations::BelongsToAssociation end end
#calculate_constructable(macro, options) (private)
[ GitHub ]734 735 736
# File 'activerecord/lib/active_record/reflection.rb', line 734
def calculate_constructable(macro, ) !polymorphic? end
#join_fk (private)
[ GitHub ]738 739 740
# File 'activerecord/lib/active_record/reflection.rb', line 738
def join_fk foreign_key end
#join_id_for(owner)
[ GitHub ]728 729 730
# File 'activerecord/lib/active_record/reflection.rb', line 728
def join_id_for(owner) # :nodoc: owner[foreign_key] end
#join_pk(klass) (private)
[ GitHub ]742 743 744
# File 'activerecord/lib/active_record/reflection.rb', line 742
def join_pk(klass) polymorphic? ? association_primary_key(klass) : association_primary_key end
#macro
[ GitHub ]716
# File 'activerecord/lib/active_record/reflection.rb', line 716
def macro; :belongs_to; end


Author: Christian Bach
Version: 2.1+ (forked from version 2.0.5, changelog)
Licence:
Dual licensed under MIT
or GPL licenses.
Contents
- Introduction
- Demo
- Getting started
- Examples
- Configuration
- Widget Options (New v2.1)
- Methods
- Events
- Download
- Compatibility
- Support
- Credits
Introduction
tablesorter is a jQuery plugin for turning a standard HTML table with THEAD and TBODY tags into a sortable table without page refreshes. tablesorter can successfully parse and sort many types of data including linked data in a cell. It has many useful features including:
- Multi-column sorting
- Multi-tbody sorting - see the options table below
- Parsers for sorting text, URIs, integers, currency, floats, IP addresses, dates (ISO, long and short formats), time. Add your own easily
- Support secondary "hidden" sorting (e.g., maintain alphabetical sort when sorting on other criteria)
- Extensibility via widget system
- Cross-browser: IE 6.0+, FF 2+, Safari 2.0+, Opera 9.0+
- Small code size
Demo
| Account # | First Name | Last Name | Age | Total | Discount | Difference | Date |
|---|---|---|---|---|---|---|---|
| A42b | Peter | Parker | 28 | $9.99 | 20.9% | +12.1 | Jul 6, 2006 8:14 AM |
| A255 | John | Hood | 33 | $19.99 | 25% | +12 | Dec 10, 2002 5:14 AM |
| A33 | Clark | Kent | 18 | $15.89 | 44% | -26 | Jan 12, 2003 11:14 AM |
| A1 | Bruce | Almighty | 45 | $153.19 | 44.7% | +77 | Jan 18, 2001 9:12 AM |
| A102 | Bruce | Evans | 22 | $13.19 | 11% | -100.9 | Jan 18, 2007 9:12 AM |
| A42a | Bruce | Evans | 22 | $13.19 | 11% | 0 | Jan 18, 2007 9:12 AM |
TIP! Sort multiple columns simultaneously by holding down the shift key and clicking a second, third or even fourth column header!
Getting started
To use the tablesorter plugin, include the jQuery
library and the tablesorter plugin inside the
tag
of your HTML document:

tablesorter works on standard HTML tables. You must include THEAD and TBODY tags:

 Last Name	 First Name	 Email	 Due	 Web Site

 Smith	 John	<EMAIL_ADDRESS>$50.00	 http://www.jsmith.com

 Bach	 Frank	<EMAIL_ADDRESS>$50.00	 http://www.frank.com

 Doe	 Jason	<EMAIL_ADDRESS>$100.00	 http://www.jdoe.com

 Conway	 Tim	<EMAIL_ADDRESS>$50.00	 http://www.timconway.com

Start by telling tablesorter to sort your table when the document is loaded:
$(function(){ $("#myTable").tablesorter(); });
Click on the headers and you'll see that your table is now sortable! You can also pass in configuration options when you initialize the table. This tells tablesorter to sort on the first and second column in ascending order.
$(function(){ $("#myTable").tablesorter({ sortList: [[0,0], [1,0]] }); });
NOTE! tablesorter will auto-detect most data types including numbers, dates, ip-adresses for more information see Examples
Examples
These examples will show what's possible with tablesorter. You need Javascript enabled to run these samples, just like you and your users will need Javascript enabled to use tablesorter.
Basic
Sorting
- Set an initial sorting order using options
- Sort table using a link outside the table
- Force a default sorting order
- Append a sort to the selected sorting order
- Child rows; how to add rows that sort with their parent row
- Child rows + filter widget; how they work together
- Direction of initial sort
- Disable sort
- Lock sort order
- Set initial sort order
- Using sortReset & sortRestart options
- Sorting empty cells (v2.1.11)
- Change the default multi-sorting key
- Custom sort script New! v2.2
- Sorting Accented Characters New! v2.2
- Sorting with Multiple Tbodies New! v2.2
- Sorting Across Multiple Columns New! v2.3
Parsers / Extracting Content
- Dealing with digits!
- Dealing with text strings in numerical sorts (v2.0.10)
- Disable or set the column parser using class names (v2.0.11)
- Disable or set the column parser using jQuery Data New! v2.3
- Changing the date format (v2.0.23)
- Parser, writing your own
- Parser, writing your own, advanced use (New v2.1)
- Dealing with markup inside cells (textExtraction function)
Widgets / Plugins
- Applying widgets
- Columns widget (v2.0.17)
- Filter widget (v2.0.18)
- Filter widget, custom New! v2.3.6
- jQuery UI theme widget (v2.0.9)
- Resizable Columns widget (v<IP_ADDRESS>)
- Save sort widget (v2.0.27)
- Sticky header widget (v<IP_ADDRESS>)
- Zebra stripe widget
- Widgets, writing your own
- Pager plugin
- Pager plugin - ajax (New v2.1)
Advanced
Adding / Removing Content
- Initializing tablesorter on a empty table
- Appending table data with ajax
- Adding a table row (v2.0.16)
- Update the table after cell content has changed
- Pager plugin - examples of how to add and remove rows
Change Header Style
Other
Options & Events
- Triggers sortEnd and sortStart (Displaying sorting progress)
- Extending default options
- Enabling debug mode
Playgrounds & Other demos
- tablesorter basic demo (includes widgets)
- tablesorter basic demo using jQuery UI theme
- tablesorter basic demo with pager plugin
- More demos - added to wiki pages
Metadata - setting inline options
- *Note* you can use class names (version 2.0.11+, demo), or jQuery data (version 2.3+, demo) instead of meta data
- Set a initial sorting order using metadata.
- Disable header using metadata
- Setting column parser using metadata
Configuration
tablesorter has many options you can pass in at initialization to achieve different effects
TIP! Click on the link in the property column to reveal full details (or toggle|show|hide all) or double click to update the browser location.
| Property | Type | Default | Description | Link | ||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Property | Type | Default | Description | Link | ||||||||||||||||||||||||
| cancelSelection | Boolean | true | Indicates if tablesorter should disable selection of text in the table header (TH). Makes header behave more like a button. | |||||||||||||||||||||||||
| cssAsc | String | "tablesorter-headerSortUp" | The CSS style used to style the header when sorting ascending. Example from the blue skin:
th.tablesorter-headerSortUp { background-color: #8dbdd8; background-image: url(black-asc.gif); } |
|||||||||||||||||||||||||
| cssChildRow | String | "expand-child" | Add this css class to a child row that should always be attached to its parent. Click on the "cssChildRow" link to toggle the view on the attached child row. | Ex:1 2 | ||||||||||||||||||||||||
| This is an entirely new row, but attached to the row above while sorting cssChildRow Example HTML:

 Item #	 Name	 Available

 12345	 Toy Car	 5

   It's a toy car!

 23456	 Toy Plane	 2

   It's a toy plane!

   and it flies!

 |
||||||||||||||||||||||||||||
| cssDesc | String | "tablesorter-headerSortDown" | The CSS style used to style the header when sorting descending. Example from the blue skin:
th.tablesorter-headerSortDown { background-color: #8dbdd8; background-image: url(black-desc.gif); } |
|||||||||||||||||||||||||
| cssHeader | String | "tablesorter-header" | The CSS style used to style the header in its unsorted state. Example from the blue skin:
th.tablesorter-header { background-color: #e6eeee; background-image: url(black-bg.gif); background-repeat: no-repeat; background-position: center right; border-collapse: collapse; cursor: pointer; font-size: 12px; padding: 4px 20px 4px 4px; } |
|||||||||||||||||||||||||
| cssInfoBlock | String | "tablesorter-infoOnly" | All tbodies with this class name will not have its contents sorted. New! v2.2.
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.

 The contents of this tbody

 will not be sorted

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. |
|||||||||||||||||||||||||
| selectorRemove | String | "tr.remove-me" | This CSS class name can be applied to all rows that are to be removed prior to triggering a table update. (New v2.1).
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.
|
|||||||||||||||||||||||||
| dateFormat | String | "mmddyyyy" | Set the date format. Here are the available options. (Modified v2.0.23).
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, set in order of priority Modified! v2.3.1:
|
Example | ||||||||||||||||||||||||
| debug | Boolean | false | Boolean flag indicating if tablesorter should display debuging information useful for development. | Example | ||||||||||||||||||||||||
| delayInit | Boolean | false | Setting this option to true will delay parsing of all table cell data until the user initializes a sort. This speeds up the initialization process of very large tables, but the data still needs to be parsed, so the delay is still present upon initial sort. | Example | ||||||||||||||||||||||||
| emptyTo | String | "bottom" |
Boolean flag indicating how tablesorter should deal with empty table cells. (Modified v2.1.16).
emptyToBottom option was added in v2.1.11, then replaced by the emptyTo option in v2.1.16.
|
Example | ||||||||||||||||||||||||
| headerList | Array | [ ] (empty array) | Internal list of each header element as selected using jQuery selectors in the selectorHeaders option. Not really useful for normal usage. |
|||||||||||||||||||||||||
| headers | Object | null |
An object of instructions for per-column controls in the format: headers: { 0: { option: setting }, ... }
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 the filter to false to disable the filter widget in this column // See the "Applying the filter widget" demo 7: { filter: false } } }); }); |
Ex:1 2 3 4 | ||||||||||||||||||||||||
| ignoreCase | Boolean | true | When true, text sorting will ignore the character case. If false, upper case characters will sort before lower case. New! v2.2. | |||||||||||||||||||||||||
| initWidgets | Boolean | true | Apply widgets after table initializes New! v2.3.5.
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. |
|||||||||||||||||||||||||
| onRenderHeader | Function | null |
This function is called when classes are added to the TH tags. You can use this to modify the HTML in each header tag for additional styling.
In versions 2.0.6+, all TH text is wrapped in a span by default. In the example below, the header cell (TH) span is given a class name (source). $(function(){ $("table").tablesorter({ onRenderHeader: function (){ $(this).find('div').addClass('roundedCorners'); } }); });and you'll end up with this HTML (only the thead is shown)

 Column 1	 Column 2

 |
Example | ||||||||||||||||||||||||
| parsers | Object | { } | Internal list of all of the parsers. Here is a complete list of default parsers:
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). |
Ex:1 2 3 | ||||||||||||||||||||||||
| selectorHeaders | String | "> thead th" | jQuery selectors used to find the header cells.
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 version 2.3 to prevent targetting nested table headers. Modified! v2.3
|
|||||||||||||||||||||||||
| sortForce | Array | null | Use to add an additional forced sort that is prepended to sortList .
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:
[[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) }); }); |
Example | ||||||||||||||||||||||||
| sortList | Array | null | Use to add an initial sort to the table.
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 (New! v2.3.1) or metadata on the table:
|
Example | ||||||||||||||||||||||||
| sortAppend | Array | null | Use to add an additional forced sort that will be appended to the dynamic selections by the user.
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.
|
Example | ||||||||||||||||||||||||
| sortInitialOrder | String | "asc" |
The direction a column sorts when clicking the header for the first time. Valid arguments are "asc" for Ascending or "desc" for Descending.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, set in order of priority Modified! v2.3.1:
|
Ex:1 2 | ||||||||||||||||||||||||
| sortLocaleCompare | Boolean | false |
Boolean flag indicating if certain accented characters within the table will be replaced with their equivalent characters. Modified! v2.2.
NOTE: See the Language wiki page for language specific examples and how to extend the character equivalent tables seen in the sortLocaleCompare demo. 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. |
Example | ||||||||||||||||||||||||
| sortReset | Boolean | false |
Setting this option to true will allow you to click on the table header a third time to reset the sort direction. (New v2.0.27).
|
Example | ||||||||||||||||||||||||
| sortRestart | Boolean | false |
Setting this option to true will start the sort with the sortInitialOrder when clicking on a previously unsorted column. (New v2.0.31).
|
Example | ||||||||||||||||||||||||
| sortMultiSortKey | String | "shiftKey" | The key used to select more than one column for multi-column sorting. Defaults to the shift key. The other options are "ctrlKey" or "altKey" . Reference: https://developer.mozilla.org/en/DOM/MouseEvent |
Example | ||||||||||||||||||||||||
| stringTo | String | "max" |
Boolean flag indicating how tablesorter should deal with text inside of numerically sorted columns. (New v2.1.16).
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:
|
Example | ||||||||||||||||||||||||
| tableClass | String | "tablesorter" | 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.
Change this option if you are not using the default css, or if you are using a completely custom stylesheet. |
|||||||||||||||||||||||||
| textExtraction | String Or Function | "simple" | Defines which method is used to extract data from a table cell for sorting.
The built-in option is "simple" which is the equivalent of doing this inside of the textExtraction function: $(node).text(); .
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 Added $(function(){ $("table").tablesorter({ textExtraction: { 1: function(node, table, cellIndex) { return $(node).find("span:last").text(); } }, headers: { 1: { sorter : "digit" } } }); }); |
Example | ||||||||||||||||||||||||
| textSorter | Function | null |
Replace the default sorting algorithm with a custom one using this option.
Include a script like naturalSort.js as follows: $(function(){ $("table").tablesorter({ textSorter : naturalSort }); });or use the localeCompare sort $(function(){ $("table").tablesorter({ textSorter: function(a,b) { return a.localeCompare(b); } }); });There's no need to worry about reverse sorting, it's taken care of by the plugin. |
Example | ||||||||||||||||||||||||
| usNumberFormat | Boolean | true |
Indicates how tablesorter should deal with a numerical format: (New v2.1.3).
|
Example | ||||||||||||||||||||||||
| widgets | Array | [ ] (empty array) |
Initialize widgets using this option ( e.g. widgets : ['zebra'] , or custom widgets widgets: ['zebra', 'myCustomWidget']; , see this demo on how to write your own custom widget ).
|
Example | ||||||||||||||||||||||||
| widthFixed | Boolean | false |
Indicates if tablesorter should apply fixed widths to the table columns. This is useful for the Pager companion.
|
Example | ||||||||||||||||||||||||
| widgetOptions | Object | { } |
As of version 2.1, all widget options have been moved into this option. This is a move to store all widget specific options in one place so as not to polute the main table options. All current widgets have been modified to use this new option. (New v2.1).
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", "stickyHeaders"], widgetOptions: { // zebra widget: adding zebra striping, using content and default styles - the ui css removes the background // from default even and odd class names included for this demo to allow switching themes // [ "even", "odd" ] zebra : ["ui-widget-content even", "ui-state-default odd"], // uitheme widget: change default uitheme icons // find the full list of icons here: http://jqueryui.com/themeroller/ (hover over them for their name) // default icons: ["ui-icon-arrowthick-2-n-s", "ui-icon-arrowthick-1-s", "ui-icon-arrowthick-1-n"] // ["up/down arrow (cssHeaders/unsorted)","down arrow (cssDesc/descending)","up arrow (cssAsc/ascending)"] uitheme : ["ui-icon-carat-2-n-s", "ui-icon-carat-1-s", "ui-icon-carat-1-n"], // columns widget: change the default column class names // primary is the first column sorted, secondary is the second, etc columns : [ "primary", "secondary", "tertiary" ], // filter widget: If there are child rows in the table (rows with class name from "cssChildRow" option) // and this option is true and a match is found anywhere in the child row, then it will make that row // visible; default is false filter_childRows : false, // filter widget: css class applied to the table row containing the filters & the inputs within that row filter_cssFilter : "tablesorter-filter", // filter widget: Set this option to true to use the filter to find text from the start of the column // So typing in "a" will find "albert" but not "frank", both have a's; default is false filter_startsWith : false, // stickyHeaders widget: css class name applied to the sticky header stickyHeaders : "tablesorter-stickyHeader" } }); }); |
Example | ||||||||||||||||||||||||
| Deprecated Options | ||||||||||||||||||||||||||||
| widgetColumns | Object with Array | { css:[ "primary", "secondary", "tertiary" ] } |
This option is being deprecated!
It has been replaced by widgetOptions.columns ; but is still available for backwards compatibility.
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)... (New 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" ] } }); }); |
|||||||||||||||||||||||||
| widgetUitheme | Object with Array | { css: [ "ui-icon-arrowthick-2-n-s", "ui-icon-arrowthick-1-s", "ui-icon-arrowthick-1-n" ] } |
This option is being deprecated!
It has been replaced by widgetOptions.uitheme ; but is still available for backwards compatibility.
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. (New 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) ] } }); }); |
|||||||||||||||||||||||||
| widgetZebra | Object with Array | { css: [ "even", "odd" ] } |
This option is being deprecated!
It has been replaced by widgetOptions.zebra ; but is still available for backwards compatibility.
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" ] } }); }); |
Widget Options
tablesorter widgets have many options, and to better organize them, they now are grouped together inside of the widgetOptions
TIP! Click on the link in the property column to reveal full details (or toggle|show|hide all) or double click to update the browser location.
| Property | Type | Default | Description | Link |
|---|---|---|---|---|
| Property | Type | Default | Description | Link |
| columns | Array | [ "primary", "secondary", "tertiary" ] |
columns widget: 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)... (Modified v2.1).
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" ] } }); }); |
Example |
| filter_childRows | Boolean | false |
Filter widget: If there are child rows in the table (rows with class name from "cssChildRow" option) and this option is true and a match is found anywhere in the child row, then it will make that row visible.
(Modified v2.1).
Use the filter_childRows option include child row text as follows:
$(function(){ $("table").tablesorter({ widgets: ["filter"], widgetOptions : { filter_childRows : true } }); }); |
|
| filter_cssFilter | String | 'tablesorter-filter' |
Filter widget: This is the class name applied to the filter header row (tr) and each input within that row. If you change it from the default class name of "tablesorter-filter" make sure you also update the css!
(New v2.1).
Use the "tablesorter-filter" option to change the 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" } }); }); |
Example |
| filter_startsWith | Boolean | false |
Set this option to true to use the filter to find text from the start of the column, so typing in "a" will find "albert" but not "frank", both have a's. (New v2.1).
Use the filter_startsWith option as follows:
$(function(){ $("table").tablesorter({ widgets: ["filter"], widgetOptions : { filter_startsWith : true } }); }); |
Example |
| filter_ignoreCase | Boolean | true |
Set this option to false to make the column content search case-insensitive, so typing in "a" will not find "Albert". New! v2.3.4
Use the filter_ignorecase option as follows:
$(function(){ $("table").tablesorter({ widgets: ["filter"], widgetOptions : { filter_ignoreCase : false } }); }); |
Example |
| filter_functions | Object | null |
Customize the filter widget by adding a select dropdown with content, custom options or custom filter functions. New! v2.3.6
Use the "filter_functions" option in three different ways:
|
Example |
| filter_searchDelay | Numeric | 300 |
Set this option to the number of milliseconds to delay the search. New! v2.3.4
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); |
|
| stickyHeaders | String | 'tablesorter-stickyHeader' |
stickyHeaders widget: This is the class name applied to the sticky header row (tr). If you change it from the default class name of "tablesorter-stickyHeader" make sure you also update the css! (New v2.1).
Use the "stickyHeaders" option to change the css class name as follows:
$(function(){ $("table").tablesorter({ widgets: ["stickyHeaders"], widgetOptions : { // css class name applied to the sticky header stickyHeaders : "tablesorter-stickyHeader" } }); }); |
Example |
| uitheme | Array | [ "ui-icon-arrowthick-2-n-s", "ui-icon-arrowthick-1-s", "ui-icon-arrowthick-1-n" ] |
uitheme widget: This widget option replaces the previous widgetUitheme. It is 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. (Modified v2.1).
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 widgetOptions: { uitheme : [ "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) ] } }); }); |
Example |
| zebra | Array | [ "even", "odd" ] |
zebra widget: When the zebra striping widget is initialized, it automatically applied the default class names of "even" and "odd" . (Modified v2.1).
Use the "zebra" option to change the css class name as follows:
$(function(){ $("table").tablesorter({ widgets: ["zebra"], // initialize zebra striping of the table widgetOptions: { zebra: [ "normal-row", "alt-row" ] } }); }); |
Example |
Methods
tablesorter has some methods available to allow updating, resorting or applying widgets to a table after it has been initialized.
TIP! Click on the link in the method column to reveal full details (or toggle|show|hide all) or double click to update the browser location.
| Method | Description | Link |
|---|---|---|
| addRows | Use this method to add table rows. (New v2.0.16).
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 = '
Inigo	Montoya	34	' + '$19.99	15%	Sep 25, 1987 12:00PM
', $row = $(row), // resort table using the current sort; set to false to prevent resort, otherwise // any other value in resort will automatically trigger the table resort. // A callback method was added in 2.3.9. resort = true, callback = function(table){ alert('rows have been added!'); }; $('table') .find('tbody').append($row) .trigger('addRows', [$row, resort, callback]); |
Example |
| sorton | Use this method to sort an initialized table in the desired order.
// 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) // A callback method was added in 2.3.9. $("table").trigger("sorton", [sort, callback]); |
Example |
| update | Update the stored tablesorter data and the table.
// Add new content $("table tbody").append(html); // let the plugin know that we made a update // the resort flag set to anything BUT false (no quotes) will trigger an automatic // table resort using the current sort // 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.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 // set sorting column and direction, this will sort on the first and third column var sorting = [[2,1],[0,0]]; $("table").trigger("sorton", [sorting]); |
Example |
| appendCache | Update a table that has had its data dynamically changed; used in conjunction with "update".
Use this method when more than just one cell like in the "updateCell" method, but you may possibly have to trigger two events: both "update" and "appendCache".
Note: This is the only method the pager widget uses - the entire table is stored in the cache, but only the visible portion is actually exists in the table. // Table data was just dynamically changed (more than one cell) $("table") .trigger("update") .trigger("appendCache"); |
|
| updateCell | Update a table cell in the tablesorter data.
$(function() { $("table").tablesorter(); $("td.discount").click(function(){ // randomize a number var resort = false, discount = '$' + Math.round(Math.random() * Math.random() * 100) + '.' + ('0' + Math.round(Math.random() * Math.random() * 100)).slice(-2); $(this).text(discount); // update the table, so the tablesorter plugin knows its value // set resort flag to false to prevent automatic resort (since we're using a different sort below) // leave the resort flag as undefined, or with any other value, to automatically resort the table // $("table").trigger("updateCell", [this]); < - resort is undefined so the table WILL resort $("table").trigger("updateCell", [this, resort]); // 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 // set sorting column and direction, this will sort on the first and third column var sorting = [[3,1]]; $("table").trigger("sorton", [sorting]); return false; }); }); |
Example |
| applyWidgetId | Apply the selected widget to the table, but the widget will not continue to be applied after each sort. See the example, it's easier than describing it.
$(function(){ // initialize tablesorter without the widget $("table").tablesorter(); // click a button to apply the zebra striping $("button").click(function(){ $('table').trigger('applyWidgetId', ['zebra']); }); |
Example |
| applyWidgets | Apply the set widgets to the table. This method can be used after a table has been initialized, but it won't work unless you update the configuration settings. See the example, it's easier than describing it.
// Update the list of widgets to apply to the table (add or remove) $("table").data("tablesorter").widgets = ["zebra"]; // This method applies the widget - no need to keep updating $('table').trigger('applyWidgets'); }); |
Example |
| destroy | Use this method to remove tablesorter from the table.
// Remove tablesorter and all classes $("table").trigger("destroy"); // Remove tablesorter and all classes but the "tablesorter" class on the table $("table").trigger("destroy", [false]; |
Events
tablesorter has some methods available to allow updating, resorting or applying widgets to a table after it has been initialized.
TIP! Click on the link in the event column to reveal full details (or toggle|show|hide all) or double click to update the browser location.
| Event | Description | Link |
|---|---|---|
| initialized | This event fires when tablesorter has completed initialization.
$(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 } }); }); |
|
| sortBegin | This event fires immediately before tablesorter begins resorting the table.
$(function(){ // initialize the tablesorter plugin $("table").tablesorter(); // bind to sort events $("table").bind("sortBegin",function(e, table) { // do something crazy! }); }); |
|
| sortStart | This event fires immediately after the tablesorter header has been clicked, initializing a resort.
$(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(); }); }); |
Example |
| sortEnd | This event fires when tablesorter has completed resorting the table.
$(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(); }); }); |
Example |
| pagerChange | This event fires when the pager plugin begins to render the table on the currently selected page. (New v2.0.7).
$(function(){ // initialize the sorter $("table") .tablesorter() // initialize the pager plugin .tablesorterPager({ container: $("#pager") }) // bind to pager events .bind('pagerChange pagerComplete', function(e,c){ // c.totalPages contains the total number of pages $('#display').html( e.type + " event triggered, now on page " + (c.page + 1) ); }); }); |
Example |
| pagerComplete | This event fires when the pager plugin has completed its render of the table on the currently selected page. (New v2.0.7).
$(function(){ // initialize the sorter $("table") .tablesorter() // initialize the pager plugin .tablesorterPager({ container: $("#pager") }) // bind to pager events .bind('pagerChange pagerComplete', function(e,c){ // c.totalPages contains the total number of pages $('#display').html( e.type + " event triggered, now on page " + (c.page + 1) ); }); }); |
Example |
Download
Full release - Plugin, Documentation, Add-ons, Themes. Download: zip or tar.gz
Pick n choose - Place at least the required files in a directory on your webserver that is accessible to a web browser. Record this location.
Required:- jQuery (1.2.6 or higher; some demos need jQuery 1.4.2+)
- jquery.tablesorter.min.js (19kb, minified for production - please put the file on your server)
- jQuery Metadata 2.1 (6kb, required for setting inline options)
- jquery.tablesorter.js (41kb/20kb min)
- jquery.tablesorter.pager.js (14kb/7kb min, demo)
- jquery.tablesorter.widgets.js (22kb/11kb min, includes the jQuery UI theme, columns styling, resizable columns, filter, sticky header and save sort widgets. (Updated v2.1)
- Green Skin - Images and CSS styles for green themed headers
- Blue Skin - Images and CSS styles for blue themed headers (as seen in the examples)
- jQuery UI Theme - Apply any jQuery UI theme to the table using the "uitheme" widget code. (New v2.0.9).
Browser Compatibility
tablesorter has been tested successfully in the following browsers with Javascript enabled:
- Firefox 2+
- Internet Explorer 6+
- Safari 2+
- Opera 9+
- Konqueror
Support
If you are having a problem with the plugin or you want to submit a feature request, please submit an issue.
If you would like to contribute, fork a copy on github.
Support is also available through the jQuery Mailing List or StackOverflow.
Access to the jQuery Mailing List is also available through Nabble Forums.
Credits
Written by Christian Bach.
Documentation written by Brian Ghidinelli,
based on Mike Alsup's great documention.
Missing documentation, alphanumeric sort, numerous widgets and other changes added by Mottie.
John Resig for the fantastic jQuery


I ought to have mentioned this earlier, but better late than never. 2008 is the International Year Of The Potato. So whether you champion Accords or Belle de Fontenays or Caras or Carlingfords or Charlottes or Desirees or Duke of Yorks or Dundrods or Estimas or Fiannas or Golden Wonders or Harmonies or Kerr's Pinks or King Edwards or Marfonas or Maris Bards or Maris Peers or Maris Pipers or Nadines or Nicolas or Ospreys or Pentland Javelins or Pink Fir Apples or Premieres or Rockets or Romanos or Roosters or Santes or Saxons or Vivaldis or Wiljas, be sure to devote much of your time and energy this year to potato-related activities. Hooting Yard will be getting into the groove with a series of potato-postings as the months go by, so keep your eyes peeled.


Status
Usage
JustJs is available on npm for server usage and distributed over a CDN for browser usage.
Browser
To use the latest version of JustJs' core over a CDN, include the following anywhere on your HTML:
<script
src="%{browser-example-url}%"
integrity="%{browser-example-sri}%"
crossorigin="anonymous"
async></script>
Then, you can replace core.min.js with any of these files and/or %{latest-version}% with any of these versions.
Server
To use the latest version of JustJs on a server, install it via npm or via yarn:
Flavors
JustJs distributes multiple files when a new version is released, therefore you should pick the one that better suits your needs...
If you don't know what to choose, "core.min.js" is always a good option...
Versioning
JustJs follows the Semantic Versioning Specification (SemVer) to version each release. However, we tag the release prepending "v" to the version.
Usually, you should avoid using release-candidates (those releases that include "-rc" on the version) and use a previous/next version instead, since those are used for testing purposes and removed after a release is no longer a candidate.
If you need more information about a certain version, please check the source code on Github.


Page 1
Page 2
Page 1
Page 2
Modern Interior
Images from
Freepik
Product 1 Title
$12
$9.95
Add to Cart
Product 2 Title
$12
$9.95
Add to Cart
Product 3 Title
$12
$9.95
Add to Cart
HTML Template
created with
Nicepage
.