A collection of simple tips to help up your jQuery game.

For other great lists check out @sindresorhus's curated list of awesome lists.

• Tips
• Support
• Translations
• Contribution Guidelines

1. Use noConflict()
2. Checking If jQuery Loaded
3. Check Whether an Element Exists
4. Use .on() Binding Instead of .click()
5. Back to Top Button
6. Preload Images
7. Checking If Images Are Loaded
8. Fix Broken Images Automatically
9. Post a Form with AJAX
10. Toggle Classes on Hover
11. Disabling Input Fields
12. Stop the Loading of Links
13. Cache jQuery Selectors
14. Toggle Fade/Slide
15. Simple Accordion
16. Make Two Divs the Same Height
17. Open External Links in New Tab/Window
18. Find Element By Text
19. Trigger on Visibility Change
20. AJAX Call Error Handling
21. Chain Plugin Calls
22. Sort List Items Alphabetically
23. Disable Right-Click

The $ alias used by jQuery is also used by other JavaScript libraries. To ensure that jQuery doesn't conflict with the $ object of different libraries, use the noConflict() method at the start of the document:

jQuery.noConflict();

Now you'll reference the jQuery object using the jQuery variable name instead of $ (e.g., jQuery('div p').hide()). If you have multiple versions of jQuery on the same page (not recommended), you can use noConflict() to set an alias to a specific version:

let $x = jQuery.noConflict();

^{back to table of contents}

Before you can do anything with jQuery you first need to make certain it has loaded:

if (typeof jQuery == 'undefined') {
  console.log('jQuery hasn\'t loaded');
} else {
  console.log('jQuery has loaded');
}

Now you're off...

^{back to table of contents}

Prior using a HTML element you need to ensure it's part of DOM.

if ($("#selector").length) {
  //do something with element
}

^{back to table of contents}

Using .on() gives you several advantages over using .click(), such as the ability to add multiple events...

.on('click tap hover')

...a binding applies to dynamically created elements, as well (there's no need to manually bind every single element dynamically added to a DOM element)...

...and the possibility to set a namespace:

.on('click.menuOpening')

Namespaces give you the power to unbind a specific event (e.g., .off('click.menuOpening')).

^{back to table of contents}

By using the animate and scrollTop methods in jQuery you don't need a plugin to create a simple scroll-to-top animation:

// Back to top
$('.container').on('click', '.back-to-top', function (e) {
  e.preventDefault();
  $('html, body').animate({scrollTop: 0}, 800);
});

<!-- Create an anchor tag -->
<div class="container">
  <a href="#" class="back-to-top">Back to top</a>
</div>

Changing the scrollTop value changes where you wants the scrollbar to land. All you're really doing is animating the body of the document throughout the course of 800 milliseconds until it scrolls to the top of the document.

^{back to table of contents}

If your web page uses a lot of images that aren't visible initially (e.g., on hover) it makes sense to preload them:

$.preloadImages = function () {
  for (var i = 0; i < arguments.length; i++) {
    $('<img>').attr('src', arguments[i]);
  }
};

$.preloadImages('img/hover-on.png', 'img/hover-off.png');

^{back to table of contents}

Sometimes you might need to check if your images have fully loaded in order to continue on with your scripts:

$('img').on('load', function () {
  console.log('image load successful');
});

You can also check if one particular image has loaded by replacing the <img> tag with an ID or class.

^{back to table of contents}

If you happen to find broken image links on your site replacing them one by one can be a pain. This simple piece of code can save a lot of headaches:

$('img').on('error', function () {
  if(!$(this).hasClass('broken-image')) {
    $(this).prop('src', 'img/broken.png').addClass('broken-image');
  }
});

Alternatively, if you wish to hide broken images this snippet will take care of that for:

$('img').on('error', function () {
  $(this).hide();
});

^{back to table of contents}

jQuery AJAX methods are a common way to request text, HTML, XML, or JSON. If you wanted to send a form via AJAX you could collect the user inputs via the val() method:

$.post('sign_up.php', {
  user_name: $('input[name=user_name]').val(),
  email:     $('input[name=email]').val(),
  password:  $('input[name=password]').val(),
});

But all of those val() calls are expensive and using .val() on <textarea> elements will strip carriage return characters from the browser-reported value. A better way of collecting user inputs is using the serialize() function which collects them as a string:

$.post('sign_up', $('#sign-up-form').serialize());

^{back to table of contents}

Let's say you want to change the visual of a clickable element on your page when a user hovers over it. You can add a class to your element when the user is hovering; when the user stops hovering removes the class:

$('.btn').on('hover', function () {
  $(this).addClass('hover');
}, function () {
  $(this).removeClass('hover');
});

You need to add the necessary CSS. If you want an even simpler way use the toggleClass method:

$('.btn').on('hover', function () {
  $(this).toggleClass('hover');
});

^{back to table of contents}

At times you may want the submit button of a form or one of its text inputs to be disabled until the user has performed a certain action (e.g., checking the "I've read the terms" checkbox). Add the disabled attribute to your input so you can enable it when you want:

$('input[type="submit"]').prop('disabled', true);

All you need to do is run the prop method again on the input, but set the value of disabled to false:

$('input[type="submit"]').prop('disabled', false);

^{back to table of contents}

Sometimes you don't want links to go to a certain web page nor reload the page; you might want them to do something else like trigger another script. This will do the trick of preventing the default action:

$('a.no-link').on('click', function (e) {
  e.preventDefault();
});

^{back to table of contents}

Think of how many times you write the same selector over and over again in any project. Every $('.element') selector has to search the entire DOM each time, regardless if that selector had previously run. Instead you can run the selector once and store the results in a variable:

var blocks = $('#blocks').find('li');

Now you can use the blocks variable wherever you want without having to search the DOM every time:

$('#hideBlocks').on('click', function () {
  blocks.fadeOut();
});

$('#showBlocks').on('click', function () {
  blocks.fadeIn();
});

Caching jQuery selectors is a good performance gain.

^{back to table of contents}

Sliding and fading are common in animations with jQuery. You might want to show an element when a user clicks something, which makes the fadeIn and slideDown methods perfect, but if you want that element to appear on the first click and then disappear on the second, this will work fine:

// Fade
$('.btn').on('click', function () {
  $('.element').fadeToggle('slow');
});

// Toggle
$('.btn').on('click', function () {
  $('.element').slideToggle('slow');
});

^{back to table of contents}

This is a simple method for a quick accordion:

// Close all panels
$('#accordion').find('.content').hide();

// Accordion
$('#accordion').find('.accordion-header').on('click', function () {
  var next = $(this).next();
  next.slideToggle('fast');
  $('.content').not(next).slideUp('fast');
  return false;
});

By adding this script all you really need to do on your web page is the necessary HTML to get this working.

^{back to table of contents}

Sometimes you'll want two divs to have the same height no matter what content they have in them:

$('.div').css('min-height', $('.main-div').height());

This example sets the min-height which means that it can be bigger than the main div but never smaller. However, a more flexible method would be to loop over a set of elements and set height to the height of the tallest element:

var $columns = $('.column');
var height = 0;
$columns.each(function () {
  if ($(this).height() > height) {
    height = $(this).height();
  }
});
$columns.height(height);

If you want all columns to have the same height:

var $rows = $('.same-height-columns');
$rows.each(function () {
  $(this).find('.column').height($(this).height());
});

^{back to table of contents}

Open external links in a new browser tab or window and ensure links on the same origin open in the same tab or window:

$('a[href^="http"]').attr('target', '_blank');
$('a[href^="//"]').attr('target', '_blank');
$('a[href^="' + window.location.origin + '"]').attr('target', '_self');

^{back to table of contents}

By using the contains() selector in jQuery you can find text in content of an element. If text doesn't exists, that element will be hidden:

var search = $('#search').val();
$('div:not(:contains("' + search + '"))').hide();

^{back to table of contents}

Trigger JavaScript when the user is no longer focusing on a tab or refocuses on a tab:

$(document).on('visibilitychange', function (e) {
  if (e.target.visibilityState === 'visible') {
    console.log('Tab is now in view!');
  } else if (e.target.visibilityState === 'hidden') {
    console.log('Tab is now hidden!');
  }
});

^{back to table of contents}

When an AJAX call returns a 404 or 500 error, the error handler will be executed. If the handler isn't defined, other jQuery code might not work as intended. To define a global AJAX error handler:

$(document).on('ajaxError', function (e, xhr, settings, error) {
  console.log(error);
});

^{back to table of contents}

jQuery allows for the "chaining" of plugin method calls to mitigate the process of repeatedly querying the DOM and creating multiple jQuery objects. Let's say the following snippet represents your plugin method calls:

$('#elem').show();
$('#elem').html('bla');
$('#elem').otherStuff();

This could be vastly improved by using chaining:

$('#elem')
  .show()
  .html('bla')
  .otherStuff();

An alternative is to cache the element in a variable (prefixed with $):

var $elem = $('#elem');
$elem.hide();
$elem.html('bla');
$elem.otherStuff();

Both chaining and caching methods in jQuery are best practices that lead to shorter and faster code.

^{back to table of contents}

Let's say you end up with too many items in a list. Maybe the content is produced by a CMS and you want to order them alphabetically:

var ul = $('#list'),
lis = $('li', ul).get();

lis.sort(function (a, b) {
  return ($(a).text().toUpperCase() < $(b).text().toUpperCase()) ? -1 : 1;
});

ul.append(lis);

There you go!

^{back to table of contents}

If you want to disable right-click, you can do it for an entire page...

$(document).ready(function () {
  $(document).bind('contextmenu', function (e) {
    return false;
  })
})

...and you can also do the same for a specific element:

$(document).ready(function () {
  $('#submit').bind('contextmenu', function (e) {
    return false;
  })
})

^{back to table of contents}

Current versions of Chrome, Firefox, Safari, Opera, Edge, and IE11.

^{back to table of contents}

• български
• Español
• Français
• Magyar
• 한국어
• Português do Europe
• Pусский
• 简体中文
• 繁體中文

^{back to table of contents}