.

• in Ajax calls

  var MyPanel = Ext.extend(Ext.Panel, {
      doSave: function(){
  	Ext.Ajax.request({
  	    url: 'your_url',
  	    params: ....
  	    success: function(response){
  		response = Ext.decode(response.responseText);
  		this.onSuccess(response)
  	    },
  	    scope: this //the scope in which the success callback is called
  	})
      },
      onSuccess: function(){ .... }
  }

  In this example, specifying the scope is very useful. By default, the success callback on Ajax calls is executed with the scope being the browser ‘window’ object, which is not very useful. In the code above, we execute the success callback in the ‘this’ scope, ‘this’ being the instance of MyPanel which executes the doSave method. This is why we can safely call this.onSuccess(response), as ‘this’ is a MyPanel object, which has the onSuccess method.
  I find the scope config property very useful, so even though specifying the scope of a function is very natural in JavaScript, the fact that ExtJS made it so natural and easy deserves being noted. Well done ExtJS!

• in Buttons

  {
      xtype: 'button',
      text: 'Save',
      handler: function(){
  	//do something on pressing the button
      },
      scope: myScope //scope of the handler
  }

• with Stores

  new Ext.data.Store({
      //...other config options
      autoLoad: {
  	callback: function(){ ... },
  	scope: aScope //for the callback function after loading the store
      }
  })

• in listeners

  new Ext.Panel({
      listeners: {
  	scope: window, //the scope of all listeners in this config
  	show: function(){ ... },
  	afterrender: function(){ ...this is 'window' }
      }
  })

• in actions

One of the things I really liked about jQuery was the “live” event.
The jQuery documentation explains it very straightforward:

[with a live event you] attach a handler to the event for all elements which match the current selector, now or in the future

I wanted to have something similar in ExtJS, and, no surprise, Ext has it, but it’s not very obvious for a newcomer.

In jQuery you can easily say:

$('p').live('click', function(){
    // do something on paragraph click
})

As it turns out, the “live” event in ExtJS is even more powerful and customizable.
In ExtJS, the equivalent of the above is:

Ext.getBody().on('click', function(event, target){
        // do something on paragraph click
    }, null, {
        delegate: 'p'
    })

For more options and configuration parameters, see Ext.Element::addListener API (Ext.Element.on() is a shorthand for the Ext.Element.addListener() method)

As can easily be seen, you can add live events not only to the body element, but to any element.

Ext.get('header').on('click', function(){
           //only handle anchors with the "menu" css class,
           //which are in the element with id="header"
     }, this /* the scope */, {
         delegate: 'a.menu'
    })

You can further distinguish between the target elements in the event callback

Ext.get('header').on('click', function(e,target){
         //an anchor with class="menu" has been clicked in
         //an element with id="header"

         // Ext.Element.is(selector) tests the current
         // item for the given selector

         // target is of type HtmlElement, not Ext.Element,
         // so wrap in Ext.get()
         if (Ext.get(target).is('.item')){
             // do smth special with anchors with "item" class
         }
     }, this /* the scope */, {
         delegate: 'a.menu'
    })

You can see a live demo here. Thanks!