callbacks.lock()

jQuery

previous page next page

callbacks.lock()

Categories: Callbacks Object

callbacks.lock() Returns: Callbacks

Description: Lock a callback list in its current state.

  • version added: 1.7callbacks.lock()

    • This method does not accept any arguments.

This method returns the Callbacks object onto which it is attached (this).

If the Callbacks object is created with the "memory" flag as its argument, additional functions may be added and fired after the callback list is locked.

Examples:

Example: Use callbacks.lock() to lock a callback list to avoid further changes being made to the list state:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
                                  

                                    

                                      
                                        // a sample logging function to be added to a callbacks list
                                      
                                    

                                  

                                  

                                    

                                      var foo = function( value ) {
                                    

                                  

                                  

                                    

                                        console.log( "foo:" + value );
                                    

                                  

                                  

                                    

                                      };
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      var callbacks = $.Callbacks();
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // add the logging function to the callback list
                                      
                                    

                                  

                                  

                                    

                                      callbacks.add( foo );
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // fire the items on the list, passing an argument
                                      
                                    

                                  

                                  

                                    

                                      callbacks.fire( "hello" );
                                    

                                  

                                  

                                    

                                      
                                        // outputs "foo: hello"
                                      
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // lock the callbacks list
                                      
                                    

                                  

                                  

                                    

                                      callbacks.lock();
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // try firing the items again
                                      
                                    

                                  

                                  

                                    

                                      callbacks.fire( "world" );
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // as the list was locked, no items
                                      
                                    

                                  

                                  

                                    

                                      
                                        // were called, so "world" isn"t logged

Example: Use callbacks.lock() to lock a callback list with "memory," and then resume using the list:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
                                  

                                    

                                      
                                        <!DOCTYPE html>
                                      
                                    

                                  

                                  

                                    

                                      
                                        <html>
                                      
                                    

                                  

                                  

                                    

                                      
                                        <head>
                                      
                                    

                                  

                                  

                                    

                                        <script src="http://code.jquery.com/jquery-latest.js"></script>
                                    

                                  

                                  

                                    

                                      
                                        </head>
                                      
                                    

                                  

                                  

                                    

                                      
                                        <body>
                                      
                                    

                                  

                                  

                                    

                                        <div id="log"></div>
                                    

                                  

                                  

                                    

                                      
                                        <script>
                                        
                                          // simple function for logging results
                                        
                                      
                                    

                                  

                                  

                                    

                                      var log = function( value) {
                                    

                                  

                                  

                                    

                                        $( "#log" ).append( "<p>" + value + "</p>" );
                                    

                                  

                                  

                                    

                                      };
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // two sample functions to be added to a callbacks list
                                      
                                    

                                  

                                  

                                    

                                      var foo = function( value ) {
                                    

                                  

                                  

                                    

                                        log( "foo: " + value );
                                    

                                  

                                  

                                    

                                      };
                                    

                                  

                                  

                                    

                                      var bar = function( value ) {
                                    

                                  

                                  

                                    

                                        log( "bar: " + value );
                                    

                                  

                                  

                                    

                                      };
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // create the callbacks object with the "memory" flag
                                      
                                    

                                  

                                  

                                    

                                      var callbacks = $.Callbacks( "memory" );
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // add the foo logging function to the callback list
                                      
                                    

                                  

                                  

                                    

                                      callbacks.add( foo );
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // fire the items on the list, passing an argument
                                      
                                    

                                  

                                  

                                    

                                      callbacks.fire( "hello" );
                                    

                                  

                                  

                                    

                                      
                                        // outputs "foo: hello"
                                      
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // lock the callbacks list
                                      
                                    

                                  

                                  

                                    

                                      callbacks.lock();
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // try firing the items again
                                      
                                    

                                  

                                  

                                    

                                      callbacks.fire( "world" );
                                    

                                  

                                  

                                    

                                      
                                        // as the list was locked, no items were called,
                                      
                                    

                                  

                                  

                                    

                                      
                                        // so "foo: world" isn't logged
                                      
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // add the foo function to the callback list again
                                      
                                    

                                  

                                  

                                    

                                      callbacks.add( foo );
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // try firing the items again
                                      
                                    

                                  

                                  

                                    

                                      callbacks.fire( "silentArgument" );
                                    

                                  

                                  

                                    

                                      
                                        // outputs "foo: hello" because the argument value was stored in memory
                                      
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        // add the bar function to the callback list
                                      
                                    

                                  

                                  

                                    

                                      callbacks.add( bar );
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      callbacks.fire( "youHadMeAtHello" );
                                    

                                  

                                  

                                    

                                      
                                        // outputs "bar: hello" because the list is still locked,
                                      
                                    

                                  

                                  

                                    

                                      
                                        // and the argument value is still stored in memory
                                      
                                    

                                  

                                  

                                    

                                      
                                        </script>
                                      
                                    

                                  

                                  

                                    

                                       
                                    

                                  

                                  

                                    

                                      
                                        </body>
                                      
                                    

                                  

                                  

                                    

                                      
                                        </html>
 POWERED BYHERONOTE
previous page start next page