Private variables like 
counter
need not be exclusive to a single closure: it is perfectly
possible for two or more nested functions to be defined within the same outer function
and share the same scope chain. Consider the following code:
function counter() {
var n = 0;
return {
count: function() { return n++; },
reset: function() { n = 0; }
};
}
var c = counter(), d = counter();   // Create two counters
c.count()                           // => 0
d.count()                           // => 0: they count independently
c.reset()                           // reset() and count() methods share state
c.count()                           // => 0: because we reset c
d.count()                           // => 1: d was not reset
The 
counter()
function returns a “counter” object. This object has two methods:
count()
returns the next integer, and 
reset()
resets the internal state. The first thing to
understand is that the two methods share access to the private variable 
n
. The second
thing to understand is that each invocation of 
counter()
creates a new scope chain and
a new private variable. So if you call 
counter()
twice, you get two counter objects with
different private variables. Calling 
count()
or 
reset()
on one counter object has no
effect on the other.
It is worth noting here that you can combine this closure technique with property
getters and setters. The following version of the 
counter()
function is a variation on
code that appeared in §6.6, but it uses closures for private state rather than relying on
a regular object property:
function counter(n) {  // Function argument n is the private variable
return {
// Property getter method returns and increments private counter var.
get count() { return n++; },
// Property setter doesn't allow the value of n to decrease
set count(m) {
if (m >= n) n = m;
else throw Error("count can only be set to a larger value");
}
};
}
var c = counter(1000);
c.count            // => 1000
c.count            // => 1001
c.count = 2000
c.count            // => 2000
c.count = 2000     // => Error!
8.6  Closures | 183
Core JavaScript
Pdf links - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add links to pdf acrobat; add hyperlink to pdf online
Pdf links - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
adding hyperlinks to pdf documents; clickable links in pdf files
Note that this version of the 
counter()
function does not declare a local variable, but
just uses its parameter 
n
to hold the private state shared by the property accessor meth-
ods. This allows the caller of 
counter()
to specify the initial value of the private variable.
Example 8-4 is a generalization of the shared private state through closures technique
we’ve been demonstrating here. This example defines an 
addPrivateProperty()
func-
tion that defines a private variable and two nested functions to get and set the value of
that variable. It adds these nested functions as methods of the object you specify:
Example 8-4. Private property accessor methods using closures
// This function adds property accessor methods for a property with
// the specified name to the object o.  The methods are named get<name>
// and set<name>.  If a predicate function is supplied, the setter
// method uses it to test its argument for validity before storing it.
// If the predicate returns false, the setter method throws an exception.
//
// The unusual thing about this function is that the property value
// that is manipulated by the getter and setter methods is not stored in
// the object o.  Instead, the value is stored only in a local variable
// in this function.  The getter and setter methods are also defined
// locally to this function and therefore have access to this local variable.
// This means that the value is private to the two accessor methods, and it 
// cannot be set or modified except through the setter method.
function addPrivateProperty(o, name, predicate) {
var value;  // This is the property value
// The getter method simply returns the value.
o["get" + name] = function() { return value; };
// The setter method stores the value or throws an exception if
// the predicate rejects the value.
o["set" + name] = function(v) {
if (predicate && !predicate(v))
throw Error("set" + name + ": invalid value " + v);
else
value = v;
};
}
// The following code demonstrates the addPrivateProperty() method.
var o = {};  // Here is an empty object
// Add property accessor methods getName and setName()
// Ensure that only string values are allowed
addPrivateProperty(o, "Name", function(x) { return typeof x == "string"; });
o.setName("Frank");       // Set the property value
console.log(o.getName()); // Get the property value
o.setName(0);             // Try to set a value of the wrong type
We’ve now seen a number of examples in which two closures are defined in the same
scope chain and share access to the same private variable or variables. This is an
184 | Chapter 8: Functions
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Embed zoom setting (fit page, fit width). Turn PDF form data to HTML form. Export PDF images to HTML images. Embed PDF hyperlinks to HTML links.
adding a link to a pdf in preview; pdf reader link
C# Image: Tutorial for Document Management Using C#.NET Imaging
more detailed C# tutorials on each part by following the links respectively are dedicated to provide powerful & profession imaging controls, PDF document, image
add link to pdf; convert doc to pdf with hyperlinks
important technique, but it is just as important to recognize when closures inadver-
tently share access to a variable that they should not share. Consider the following code:
// This function returns a function that always returns v
function constfunc(v) { return function() { return v; }; }
// Create an array of constant functions:
var funcs = [];
for(var i = 0; i < 10; i++) funcs[i] = constfunc(i);
// The function at array element 5 returns the value 5.
funcs[5]()    // => 5
When working with code like this that creates multiple closures using a loop, it is a
common error to try to move the loop within the function that defines the closures.
Think about the following code, for example:
// Return an array of functions that return the values 0-9
function constfuncs() {
var funcs = [];
for(var i = 0; i < 10; i++) 
funcs[i] = function() { return i; };
return funcs;
}
var funcs = constfuncs();
funcs[5]()    // What does this return?
The code above creates 10 closures, and stores them in an array. The closures are all
defined within the same invocation of the function, so they share access to the variable
i
. When 
constfuncs()
returns, the value of the variable 
i
is 10, and all 10 closures share
this value. Therefore, all the functions in the returned array of functions return the same
value, which is not what we wanted at all. It is important to remember that the scope
chain associated with a closure is “live.” Nested functions do not make private copies
of the scope or make static snapshots of the variable bindings.
Another thing to remember when writing closures is that 
this
is a JavaScript keyword,
not a variable. As discussed earlier, every function invocation has a 
this
value, and a
closure cannot access the 
this
value of its outer function unless the outer function has
saved that value into a variable:
var self = this;  // Save this value in a variable for use by nested funcs.
The 
arguments
binding is similar. This is not a language keyword, but it is automatically
declared for every function invocation. Since a closure has its own binding for
arguments
, it cannot access the outer function’s arguments array unless the outer func-
tion has saved that array into a variable by a different name:
var outerArguments = arguments;  // Save for use by nested functions
Example 8-5, later in this chapter, defines a closure that uses these techniques to refer
to both the 
this
and 
arguments
values of the outer function.
8.6  Closures | 185
Core JavaScript
.NET PDF Document Viewing, Annotation, Conversion & Processing
PDF Write. Insert text, text box into PDF. Edit, delete text from PDF. Insert images into PDF. Edit, remove images from PDF. Add, edit, delete links. Form Process
add url pdf; add links in pdf
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Available zoom setting (fit page, fit width).
add url to pdf; adding links to pdf document
8.7  Function Properties, Methods, and Constructor
We’ve seen that functions are values in JavaScript programs. The 
typeof
operator re-
turns the string “function” when applied to a function, but functions are really a spe-
cialized kind of JavaScript object. Since functions are objects, they can have properties
and methods, just like any other object. There is even a 
Function()
constructor to create
new function objects. The subsections that follow document function properties and
methods and the 
Function()
constructor. You can also read about these in the reference
section.
8.7.1  The length Property
Within the body of a function, 
arguments.length
specifies the number of arguments
that were passed to the function. The 
length
property of a function itself, however, has
a different meaning. This read-only property returns the arity of the function—the
number of parameters it declares in its parameter list, which is usually the number of
arguments that the function expects.
The following code defines a function named 
check()
that is passed the 
arguments
array
from another function. It compares 
arguments.length
(the number of arguments ac-
tually passed) to 
arguments.callee.length
(the number expected) to determine wheth-
er the function was passed the right number of arguments. If not, it throws an exception.
The 
check()
function is followed by a test function 
f()
that demonstrates how
check()
can be used:
// This function uses arguments.callee, so it won't work in strict mode.
function check(args) {
var actual = args.length;          // The actual number of arguments
var expected = args.callee.length; // The expected number of arguments
if (actual !== expected)           // Throw an exception if they differ.
throw Error("Expected " + expected + "args; got " + actual);
}
function f(x, y, z) {
check(arguments);  // Check that the actual # of args matches expected #.
return x + y + z;  // Now do the rest of the function normally.
}
8.7.2  The prototype Property
Every function has a 
prototype
property that refers to an object known as the prototype
object. Every function has a different prototype object. When a function is used as a
constructor, the newly created object inherits properties from the prototype object.
Prototypes and the 
prototype
property were discussed in §6.1.3 and will be covered
again in Chapter 9.
186 | Chapter 8: Functions
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
keeps the elements (like images, tables and chats) of original PDF file and maintains the original text style (including font, size, color, links and boldness
add hyperlink to pdf; add hyperlink pdf
How to C#: Basic SDK Concept of XDoc.PDF for .NET
XDoc.PDF for .NET allows C# developers to edit hyperlink of PDF document, including editing PDF url links and quick navigation link in bookmark/outline.
add links to pdf in preview; convert excel to pdf with hyperlinks
8.7.3  The call() and apply() Methods
call()
and 
apply()
allow you to indirectly invoke (§8.2.4) a function as if it were a
method of some other object. (We used the 
call()
method in Example 6-4 to invoke
Object.prototype.toString
on an object whose class we wanted to determine, for ex-
ample.) The first argument to both 
call()
and 
apply()
is the object on which the func-
tion is to be invoked; this argument is the invocation context and becomes the value
of the 
this
keyword within the body of the function. To invoke the function 
f()
as a
method of the object 
o
(passing no arguments), you could use either 
call()
or 
apply()
:
f.call(o);
f.apply(o);
Either of the lines of code above are similar to the following (which assume that 
o
does
not already have a property named 
m
):
o.m = f;     // Make f a temporary method of o.
o.m();       // Invoke it, passing no arguments.
delete o.m;  // Remove the temporary method.
In ECMAScript 5 strict mode the first argument to 
call()
or 
apply()
becomes the value
of 
this
, even if it is a primitive value or 
null
or 
undefined
. In ECMAScript 3 and non-
strict mode, a value of 
null
or 
undefined
is replaced with the global object and a prim-
itive value is replaced with the corresponding wrapper object.
Any arguments to 
call()
after the first invocation context argument are the values that
are passed to the function that is invoked. For example, to pass two numbers to the
function 
f()
and invoke it as if it were a method of the object 
o
, you could use code
like this:
f.call(o, 1, 2);
The 
apply()
method is like the 
call()
method, except that the arguments to be passed
to the function are specified as an array:
f.apply(o, [1,2]);
If a function is defined to accept an arbitrary number of arguments, the 
apply()
method
allows you to invoke that function on the contents of an array of arbitrary length. For
example, to find the largest number in an array of numbers, you could use the
apply()
method to pass the elements of the array to the 
Math.max()
function:
var biggest = Math.max.apply(Math, array_of_numbers);
Note that 
apply()
works with array-like objects as well as true arrays. In particular, you
can invoke a function with the same arguments as the current function by passing the
arguments
array directly to 
apply()
. The following code demonstrates:
// Replace the method named m of the object o with a version that logs
// messages before and after invoking the original method.
function trace(o, m) {
var original = o[m];  // Remember original method in the closure.
o[m] = function() {   // Now define the new method.
console.log(new Date(), "Entering:", m);      // Log message.
8.7  Function Properties, Methods, and Constructor | 187
Core JavaScript
VB.NET PDF: Basic SDK Concept of XDoc.PDF
XDoc.PDF for .NET allows VB.NET developers to edit hyperlink of PDF document, including editing PDF url links and quick navigation link in bookmark/outline.
change link in pdf; add email link to pdf
C# Create PDF Library SDK to convert PDF from other file formats
file. Create and save editable PDF with a blank page, bookmarks, links, signatures, etc. Create fillable PDF document with fields.
pdf link to email; add url link to pdf
var result = original.apply(this, arguments); // Invoke original.
console.log(new Date(), "Exiting:", m);       // Log message.
return result;                                // Return result.
};
}
This 
trace()
function is passed an object and a method name. It replaces the specified
method with a new method that “wraps” additional functionality around the original
method. This kind of dynamic alteration of existing methods is sometimes called
“monkey-patching.”
8.7.4  The bind() Method
The 
bind()
method was added in ECMAScript 5, but it is easy to simulate in
ECMAScript 3. As its name implies, the primary purpose of 
bind()
is to bind a function
to an object. When you invoke the 
bind()
method on a function 
f
and pass an object
o
, the method returns a new function. Invoking the new function (as a function) invokes
the original function 
f
as a method of 
o
. Any arguments you pass to the new function
are passed to the original function. For example:
function f(y) { return this.x + y; } // This function needs to be bound
var o = { x : 1 };                   // An object we'll bind to
var g = f.bind(o);                   // Calling g(x) invokes o.f(x)
g(2)                                 // => 3
It is easy to accomplish this kind of binding with code like the following:
// Return a function that invokes f as a method of o, passing all its arguments.
function bind(f, o) {
if (f.bind) return f.bind(o);     // Use the bind method, if there is one
else return function() {          // Otherwise, bind it like this
return f.apply(o, arguments);
};
}
The ECMAScript 5 
bind()
method does more than just bind a function to an object. It
also performs partial application: any arguments you pass to 
bind()
after the first are
bound along with the 
this
value. Partial application is a common technique in func-
tional programming and is sometimes called currying. Here are some examples of the
bind()
method used for partial application:
var sum = function(x,y) { return x + y };     // Return the sum of 2 args
// Create a new function like sum, but with the this value bound to null
// and the 1st argument bound to 1.  This new function expects just one arg.
var succ = sum.bind(null, 1);
succ(2)      // => 3: x is bound to 1, and we pass 2 for the y argument
function f(y,z) { return this.x + y + z };  // Another function that adds
var g = f.bind({x:1}, 2);                   // Bind this and y
g(3)         // => 6: this.x is bound to 1, y is bound to 2 and z is 3
We can bind the 
this
value and perform partial application in ECMAScript 3. The
standard 
bind()
method can be simulated with code like that shown in Example 8-5.
188 | Chapter 8: Functions
Note that we save this method as 
Function.prototype.bind
, so that all function objects
inherit it. This technique is explained in detail in §9.4.
Example 8-5. A Function.bind() method for ECMAScript 3
if (!Function.prototype.bind) {
Function.prototype.bind = function(o /*, args */) {
// Save the this and arguments values into variables so we can
// use them in the nested function below.
var self = this, boundArgs = arguments;
// The return value of the bind() method is a function
return function() {
// Build up an argument list, starting with any args passed
// to bind after the first one, and follow those with all args
// passed to this function.
var args = [], i;
for(i = 1; i < boundArgs.length; i++) args.push(boundArgs[i]);
for(i = 0; i < arguments.length; i++) args.push(arguments[i]);
// Now invoke self as a method of o, with those arguments
return self.apply(o, args);
};
};
}
Notice that the function returned by this 
bind()
method is a closure that uses the var-
iables 
self
and 
boundArgs
declared in the outer function, even though that inner func-
tion has been returned from the outer function and is invoked after the outer function
has returned.
The 
bind()
method defined by ECMAScript 5 does have some features that cannot be
simulated with the ECMAScript 3 code shown above. First, the true 
bind()
method
returns a function object with its 
length
property properly set to the arity of the bound
function minus the number of bound arguments (but not less than zero). Second, the
ECMAScript 5 
bind()
method can be used for partial application of constructor func-
tions. If the function returned by 
bind()
is used as a constructor, the 
this
passed to
bind()
is ignored, and the original function is invoked as a constructor, with some
arguments already bound. Functions returned by the 
bind()
method do not have a
prototype
property (the 
prototype
property of regular functions cannot be deleted) and
objects created when these bound functions are used as constructors inherit from the
prototype
of the original, unbound constructor. Also, a bound constructor works just
like the unbound constructor for the purposes of the 
instanceof
operator.
8.7.5  The toString() Method
Like all JavaScript objects, functions have a 
toString()
method. The ECMAScript spec
requires this method to return a string that follows the syntax of the function declara-
tion statement. In practice most (but not all) implementations of this 
toString()
meth-
od return the complete source code for the function. Built-in functions typically return
a string that includes something like “[native code]” as the function body.
8.7  Function Properties, Methods, and Constructor | 189
Core JavaScript
8.7.6  The Function() Constructor
Functions are usually defined using the 
function
keyword, either in the form of a func-
tion definition statement or a function literal expression. But functions can also be
defined with the 
Function()
constructor. For example:
var f = new Function("x", "y", "return x*y;");
This line of code creates a new function that is more or less equivalent to a function
defined with the familiar syntax:
var f = function(x, y) { return x*y; }
The 
Function()
constructor expects any number of string arguments. The last argument
is the text of the function body; it can contain arbitrary JavaScript statements, separated
from each other by semicolons. All other arguments to the constructor are strings that
specify the parameters names for the function. If you are defining a function that takes
no arguments, you simply pass a single string—the function body—to the constructor.
Notice that the 
Function()
constructor is not passed any argument that specifies a name
for the function it creates. Like function literals, the 
Function()
constructor creates
anonymous functions.
There are a few points that are important to understand about the 
Function()
constructor:
• The 
Function()
constructor allows JavaScript functions to be dynamically created
and compiled at runtime.
• The 
Function()
constructor parses the function body and creates a new function
object each time it is called. If the call to the constructor appears within a loop or
within a frequently called function, this process can be inefficient. By contrast,
nested functions and function definition expressions that appear within loops are
not recompiled each time they are encountered.
• A last, very important point about the 
Function()
constructor is that the functions
it creates do not use lexical scoping; instead, they are always compiled as if they
were top-level functions, as the following code demonstrates:
var scope = "global";
function constructFunction() {
var scope = "local";
return new Function("return scope");  // Does not capture the local scope!
}
// This line returns "global" because the function returned by the
// Function() constructor does not use the local scope.
constructFunction()();  // => "global"
The 
Function()
constructor is best thought of as a globally-scoped version of 
eval()
(see §4.12.2) that defines new variables and functions in its own private scope. You
should rarely need to use this constructor in your code.
190 | Chapter 8: Functions
8.7.7  Callable Objects
We learned in §7.11 that there are “array-like” objects that are not true arrays but can
be treated like arrays for most purposes. A similar situation exists for functions. A
callable object is any object that can be invoked in a function invocation expression.
All functions are callable, but not all callable objects are functions.
Callable objects that are not functions are encountered in two situations in today’s
JavaScript implementations. First, the IE web browser (version 8 and before) imple-
ments client-side methods such as 
Window.alert()
and 
Document.getElementsById()
using callable host objects rather than native Function objects. These methods work
the same in IE as they do in other browsers, but they are not actually Function objects.
IE9 switches to using true functions, so this kind of callable object will gradually be-
come less common.
The other common form of callable objects are RegExp objects—in many browsers,
you can invoke a RegExp object directly as a shortcut for invoking its 
exec()
method.
This is a completely nonstandard feature of JavaScript that was introduced by Netscape
and copied by other vendors for compatibility. Do not write code that relies on the
callability of RegExp objects: this feature is likely to be deprecated and removed in the
future. The 
typeof
operator is not interoperable for callable RegExps. In some browsers
it returns “function” and in others it returns “object”.
If you want to determine whether an object is a true function object (and has function
methods) you can test its class attribute (§6.8.2) using the technique shown in
Example 6-4:
function isFunction(x) { 
return Object.prototype.toString.call(x) === "[object Function]";
}
Note that this 
isFunction()
function is quite similar to the 
isArray()
function shown
in §7.10.
8.8  Functional Programming
JavaScript is not a functional programming language like Lisp or Haskell, but the fact
that JavaScript can manipulate functions as objects means that we can use functional
programming techniques in JavaScript. The ECMAScript 5 array methods such as
map()
and 
reduce()
lend themselves particularly well to a functional programming style.
The sections that follow demonstrate techniques for functional programming in Java-
Script. They are intended as a mind-expanding exploration of the power of JavaScript’s
functions, not as a prescription for good programming style.
5
5.If this piques your interest, you may be interested in using (or at least reading about) Oliver Steele’s
Functional JavaScript library. See http://osteele.com/sources/javascript/functional/.
8.8  Functional Programming | 191
Core JavaScript
8.8.1  Processing Arrays with Functions
Suppose we have an array of numbers and we want to compute the mean and standard
deviation of those values. We might do that in nonfunctional style like this:
var data = [1,1,3,5,5];  // This is our array of numbers
// The mean is the sum of the elements divided by the number of elements
var total = 0;
for(var i = 0; i < data.length; i++) total += data[i];
var mean = total/data.length;                  // The mean of our data is 3
// To compute the standard deviation, we first sum the squares of 
// the deviation of each element from the mean.
total = 0;
for(var i = 0; i < data.length; i++) {
var deviation = data[i] - mean;
total += deviation * deviation;
}
var stddev = Math.sqrt(total/(data.length-1));  // The standard deviation is 2
We can perform these same computations in concise functional style using the array
methods 
map()
and 
reduce()
like this (see §7.9 to review these methods):
// First, define two simple functions
var sum = function(x,y) { return x+y; };
var square = function(x) { return x*x; };
// Then use those functions with Array methods to compute mean and stddev
var data = [1,1,3,5,5];
var mean = data.reduce(sum)/data.length;
var deviations = data.map(function(x) {return x-mean;});
var stddev = Math.sqrt(deviations.map(square).reduce(sum)/(data.length-1));
What if we’re using ECMAScript 3 and don’t have access to these newer array methods?
We can define our own 
map()
and 
reduce()
functions that use the built-in methods if
they exist:
// Call the function f for each element of array a and return
// an array of the results.  Use Array.prototype.map if it is defined.
var map = Array.prototype.map
? function(a, f) { return a.map(f); }  // Use map method if it exists
: function(a,f) {                      // Otherwise, implement our own
var results = [];
for(var i = 0, len = a.length; i < len; i++) {
if (i in a) results[i] = f.call(null, a[i], i, a);
}
return results;
};
// Reduce the array a to a single value using the function f and
// optional initial value.  Use Array.prototype.reduce if it is defined.
var reduce = Array.prototype.reduce
? function(a, f, initial) {   // If the reduce() method exists.
if (arguments.length > 2)
return a.reduce(f, initial);   // If an initial value was passed.
192 | Chapter 8: Functions
Documents you may be interested
Documents you may be interested