Jquery

Updates!!:

What can we do to fix this?

You can try moving the jQuery.js to top and than use jQuery.noConflict().

If that is not an option you can do the following –

IMPORTANT – Do not use [REPLACE ALL]

Edit prototype.js – find where it defines function $() and change the name to function $$$()
Still in prototype.js, carefully replace each occurrence of $(…) with $$$(…), but don’t touch anything which says $$(…)
Edit each of the other *.js files (e.g. effects.js) and carefully replace each occurrence of $(…) with $$$(…), but don’t touch anything which says $$(…).
That is it.

And just in case you have trouble doing the above, Following links point to already edited prototype.js and effects.js. Please remember all the references to these files must start with $$$ instead of $.

Download – Prototype.js

Download – Effects.js

quoted from: coolwebdeveloper.com

—

GENERAL

The jQuery library, and virtually all of its plugins are constrained within the jQuery namespace. As a general rule, “global” objects are stored inside the jQuery namespace as well, so you shouldn’t get a clash between jQuery and any other library (like Prototype, MooTools, or YUI).

That said, there is one caveat: By default, jQuery uses “$” as a shortcut for “jQuery”

OVERRIDING THE `$`-FUNCTION

However, you can override that default by calling jQuery.noConflict() at any point after jQuery and the other library have both loaded. For example:

 <html>
 <head>
   <script src="prototype.js"></script>
   <script src="jquery.js"></script>
   <script>
     jQuery.noConflict();

     // Use jQuery via jQuery(...)
     jQuery(document).ready(function(){
       jQuery("div").hide();
     });

     // Use Prototype with $(...), etc.
     $('someid').hide();
   </script>
 </head>
 <body></body>
 </html>

This will revert $ back to its original library. You’ll still be able to use “jQuery” in the rest of your application.

Additionally, there’s another option. If you want to make sure that jQuery won’t conflict with another library – but you want the benefit of a short name, you could do something like this:

 <html>
 <head>
   <script src="prototype.js"></script>
   <script src="jquery.js"></script>
   <script>
     var $j = jQuery.noConflict();

     // Use jQuery via $j(...)
     $j(document).ready(function(){
       $j("div").hide();
     });

     // Use Prototype with $(...), etc.
     $('someid').hide();
   </script>
 </head>
 <body></body>
 </html>

You can define your own alternate names (e.g. jq, $J, awesomeQuery – anything you want).

Finally, if you don’t want to define another alternative to the jQuery name (you really like to use $ and don’t care about using another library’s $ method), then there’s still another solution for you. This is most frequently used in the case where you still want the benefits of really short jQuery code, but don’t want to cause conflicts with other libraries.

 <html>
 <head>
   <script src="prototype.js"></script>
   <script src="jquery.js"></script>
   <script>
     jQuery.noConflict();

     // Put all your code in your document ready area
     jQuery(document).ready(function($){
       // Do jQuery stuff using $
       $("div").hide();
     });

     // Use Prototype with $(...), etc.
     $('someid').hide();
   </script>
 </head>
 <body></body>
 </html>

This is probably the ideal solution for most of your code, considering that there’ll be less code that you’ll have to change, in order to achieve complete compatibility.

Also see: Custom Alias

INCLUDING `JQUERY` BEFORE OTHER LIBRARIES

If you include jQuery before other libraries, you may use “jQuery” when you do some work with jQuery, and the “$” is also the shortcut for the other library. There is no need for overriding the $-function by calling “jQuery.noConflict()”.

 <html>
 <head>
   <script src="jquery.js"></script>
   <script src="prototype.js"></script>
   <script>
     // Use jQuery via jQuery(...)
     jQuery(document).ready(function(){
       jQuery("div").hide();
     });

     // Use Prototype with $(...), etc.
     $('someid').hide();
   </script>
 </head>
 <body></body>
 </html>

REFERENCING MAGIC – SHORTCUTS FOR `JQUERY`

If you don’t like typing the full “jQuery” all the time, there are some alternative shortcuts:

Reassign jQuery to another shortcut
- var $j = jQuery;
- (This might be the best approach if you wish to use different libraries)
Use the following technique, which allows you to use $ inside of a block of code without permanently overwriting $:
- (function($) { /* some code that uses $ */ })(jQuery)
- Note: If you use this technique, you will not be able to use Prototype methods inside this capsuled function that expect $ to be Prototype’s $, so you’re making a choice to use only jQuery in that block.
Use the argument to the jQuery(document).ready(function($) {})

DOM ready event:

- jQuery(function($) { /* some code that uses $ */ });
- Note: Again, inside that block you can’t use Prototype methods.

—

quotes: docs.jquery.com

Introduction

jQuery is awesome. I’ve been using it for about a year now and although I was impressed to begin with I’m liking it more and more the longer I use it and the more I find out about it’s inner workings.

I’m no jQuery expert. I don’t claim to be, so if there are mistakes in this article then feel free to correct me or make suggestions for improvements.

I’d call myself an “intermediate” jQuery user and I thought some others out there could benefit from all the little tips, tricks and techniques I’ve learned over the past year. The article also ended up being a lot longer than I thought it was going to be so I’ll start with a table of contents so you can skip to the bits you’re interested in.

1. Load the framework from Google Code

Google have been hosting several JavaScript libraries for a while now on Google Code and there are several advantages to loading it from them instead of from your server. It saves on bandwidth, it’ll load very quickly from Google’s CDN and most importantly it’ll already be cached if the user has visited a site which delivers it from Google Code.

This makes a lot of sense. How many sites out there are serving up identical copies of jQuery that aren’t getting cached? It’s easy to do too…

// Load jQuery
google.load(“jquery”, “1.2.6”);

google.setOnLoadCallback(function() {
// Your code goes here.
});

</script>

Or, you can just include a direct reference like this…

Full instructions here

2. Use a cheat sheet

Not just a jQuery tip, there are some great cheat sheets out there for most languages. It’s handy having every function on a printable A4 sheet for reference and luckily these guys have produced a couple of nice ones..

http://www.gscottolson.com/weblog/2008/01/11/jquery-cheat-sheet/
http://colorcharge.com/jquery/

3. Combine all your scripts and minify them

OK, a general JavaScript tip here. But any big project that uses lots of jQuery probably uses lots of plugins (this site uses easing, localScroll, lightbox and preload) so it’s usually applicable.

Browsers can’t load scripts concurrently (well, most can’t, yet), which means that if you’ve got several scripts downloading one at a time then you’re really slowing down the loading of your page. So, assuming the scrips are being loaded on every page then you should consider combining them into one long script before deploying.

Some of the plugins will already be minified, but you should consider packing your scripts and any that aren’t already. It only takes a few seconds. I’m personally a fan of Packer by Dean Edwards

4. Use Firebug’s excellent console logging facilities

If you haven’t already installed Firebug then you really should. Aside from many other useful features such as allowing you to inspect http traffic and find problems with your CSS it has excellent logging commands that allow you to easily debug your scripts.

Here’s a full explanation of all of it’s features

My favourite features are “console.info”, which you can use to just dump messages and variables to the screen without having to use alert boxes and “console.time” which allows you to easily set up a timer to wrap a bunch of code and see how long it takes. They’re all really easy to use too…

console.time(‘create list’);

for (i = 0; i < 1000; i++) {
var myList = $(‘.myList’);
myList.append(‘This is list item ‘ + i);
}

console.timeEnd(‘create list’);

In this instance I’ve deliberately written some very inefficient code! In the next few tips I’ll show you how we can use the timer to show some improvements which can be made.

5. Keep selection operations to a minimum by caching

jQuery selectors are awesome. They make selecting any element on the page incredibly simple, but internally they have to do a fair amount of work and if you go mad with them you might find things starting to get pretty slow.

If you’re selecting the same element time and time again (in a loop for example) then you can just select it once and keep it in memory while you manipulate it to your heart’s content. Take the following example where we add items to an unordered list using a loop.

for (i = 0; i < 1000; i++) {
var myList = $(‘.myList’);
myList.append(‘This is list item ‘ + i);
}

That takes 1066 milliseconds on my PC in Firefox 3 (imagine how long it would IE6!), which is pretty slow in JavaScript terms. Now take a look at the following code where we use the selector just once.

var myList = $(‘.myList’);

for (i = 0; i < 1000; i++) {
myList.append(‘This is list item ‘ + i);
}

That only takes 224 milliseconds, more than 4x faster, just by moving one line of code.

6. Keep DOM manipulation to a minimum

We can make the code from the previous tip even faster by cutting down on the number of times we insert into the DOM. DOM insertion operations like .append() .prepend() .after() and .wrap() are relatively costly and performing lots of them can really slow things down.

All we need to do is use string concatenation to build the list and then use a single function to add them to your unordered list like .html() is much quicker. Take the following example…

var myList = $(‘#myList’);

for (i=0; i<1000; i++){
myList.append(‘This is list item ‘ + i);
}

On my PC that takes 216 milliseconds , just over a 1/5th of a second, but if we build the list items as a string first and use the HTML method to do the insert, like this….

var myList = $(‘.myList’);
var myListItems = ”;

for (i = 0; i < 1000; i++) {
myListItems += ‘<li>This is list item ‘ + i + ‘</li>’;
}

myList.html(myListItems);

That takes 185 milliseconds, not much quicker but that’s another 31 milliseconds off the time.

7. Wrap everything in a single element when doing any kind of DOM insertion

OK, don’t ask me why this one works (I’m sure a more experienced coder will explain).

In our last example we inserted 1000 list items into an unordered list using the .html() method. If we had have wrapped them in the UL tag before doing the insert and inserted the completed UL into another tag (a DIV) then we’re effectively only inserting 1 tag, not 1000, which seems to be much quicker. Like this…

var myList = $(‘.myList’);
var myListItems = ‘<ul>’;

for (i = 0; i < 1000; i++) {
myListItems += ‘<li>This is list item ‘ + i + ‘</li>’;
}

myListItems += ‘</ul>’;
myList.html(myListItems);

he time is now only 19 milliseconds, a massive improvement, 50x faster than our first example.

8. Use IDs instead of classes wherever possible

jQuery makes selecting DOM elements using classes as easy as selecting elements by ID used to be, so it’s tempting to use classes much more liberally than before. It’s still much better to select by ID though because jQuery uses the browser’s native method (getElementByID) to do this and doesn’t have to do any of it’s own DOM traversal, which is much faster. How much faster? Let’s find out.

I’ll use the previous example and adapt it so each LI we create has a unique class added to it. Then I’ll loop through and select each one once.

// Create our list
var myList = $(‘.myList’);
var myListItems = ‘<ul>’;

for (i = 0; i < 1000; i++) {
myListItems += ‘<li>This is a list item</li>’;
}

myListItems += ‘</ul>’;
myList.html(myListItems);

// Select each item once
for (i = 0; i < 1000; i++) {
var selectedItem = $(‘.listItem’ + i);
}

Just as I thought my browser had hung, it finished, in 5066 milliseconds (over 5 seconds). So i modified the code to give each item an ID instead of a class and then selected them using the ID.

// Create our list
var myList = $(‘.myList’);
var myListItems = ‘<ul>’;

for (i = 0; i < 1000; i++) {
myListItems += ‘<li id=”listItem’ + i + ‘”>This is a list item</li>’;
}

myListItems += ‘</ul>’;
myList.html(myListItems);

// Select each item once
for (i = 0; i < 1000; i++) {
var selectedItem = $(‘#listItem’ + i);
}

This time it only took 61 milliseconds. Nearly 100x faster.

9. Give your selectors a context

By default, when you use a selector such as $(‘.myDiv’) the whole of the DOM will be traversed, which depending on the page could be expensive.

The jQuery function takes a second parameter when performing a selection.

jQuery( expression, context )

By providing a context to the selector, you give it an element to start searching within so that it doesn’t have to traverse the whole of the DOM.

To demonstrate this, let’s take the first block of code from the tip above. It creates an unordered list with 1000 items, each with an individual class. It then loops through and selects each item once. You’ll remember that when selecting by class it took just over 5 seconds to select all 1000 of them using this selector.

var selectedItem = $(‘#listItem’ + i);

then added a context so that it was only running the selector inside the unordered list, like this…

var selectedItem = $(‘#listItem’ + i, $(‘.myList’));

It still took 3818 milliseconds because it’s still horribly inefficient, but that’s more than a 25% speed increase by making a small modification to a selector.

10. Use chaining properly

One of the coolest things about jQuery is it’s ability to chain method calls together. So, for example, if you want to switch the class on an element.

$(‘myDiv’).removeClass(‘off’).addClass(‘on’);

…

—

source: tvidesign.co.uk