Pdf links SDK Library API .net wpf azure sharepoint %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D20-part1549

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

. 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()

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

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

. When

constfuncs()

returns, the value of the variable

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

(passing no arguments), you could use either

call()

apply()

f.call(o);

f.apply(o);

Either of the lines of code above are similar to the following (which assume that

does

not already have a property named

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()

apply()

becomes the value

this

, even if it is a primitive value or

null

undefined

. In ECMAScript 3 and non-

strict mode, a value of

null

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

, 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

and pass an object

, the method returns a new function. Invoking the new function (as a function) invokes

the original function

as a method of

. 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.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