open pdf and draw c# : Add hyperlinks to pdf online SDK Library service wpf .net html dnn %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D19-part1547

Functions like this one that can accept any number of arguments are called variadic
functions, variable arity functions, or varargs functions. This book uses the most collo-
quial term, varargs, which dates to the early days of the C programming language.
Note that varargs functions need not allow invocations with zero arguments. It is per-
fectly reasonable to use the 
arguments[]
object to write functions that expect some fixed
number of named and required arguments followed by an arbitrary number of un-
named optional arguments.
Remember that 
arguments
is not really an array; it is an Arguments object. Each Argu-
ments object defines numbered array elements and a 
length
property, but it is not
technically an array; it is better to think of it as an object that happens to have some
numbered properties. See §7.11 for more on array-like objects.
The Arguments object has one very unusual feature. In non-strict mode, when a func-
tion has named parameters, the array elements of the Arguments object are aliases for
the parameters that hold the function arguments. The numbered elements of the Ar-
guments object and the parameter names are like two different names for the same
variable. Changing the value of an argument with an argument name changes the value
that is retrieved through the 
arguments[]
array. Conversely, changing the value of an
argument through the 
arguments[]
array changes the value that is retrieved by the ar-
gument name. Here is an example that clarifies this:
function f(x) {
console.log(x);       // Displays the initial value of the argument
arguments[0] = null;  // Changing the array element also changes x!
console.log(x);       // Now displays "null"
}
This is emphatically not the behavior you would see if the Arguments object were an
ordinary array. In that case, 
arguments[0]
and 
x
could refer initially to the same value,
but a change to one would have no effect on the other.
This special behavior of the Arguments object has been removed in the strict mode of
ECMAScript 5. There are other strict-mode differences as well. In non-strict functions,
arguments
is just an identifier. In strict mode, it is effectively a reserved word. Strict-
mode functions cannot use 
arguments
as a parameter name or as a local variable name,
and they cannot assign values to 
arguments
.
8.3.2.1  The callee and caller properties
In addition to its array elements, the Arguments object defines 
callee
and 
caller
prop-
erties. In ECMAScript 5 strict mode, these properties are guaranteed to raise a Type-
Error if you try to read or write them. Outside of strict mode, however, the ECMAScript
standard says that the 
callee
property refers to the currently running function.
caller
is a nonstandard but commonly implemented property that refers to the function
that called this one. The 
caller
property gives access to the call stack, and the 
callee
property is occasionally useful to allow unnamed functions to call themselves
recursively:
8.3  Function Arguments and Parameters | 173
Core JavaScript
Add hyperlinks to pdf online - 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 pdf
Add hyperlinks to pdf online - 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
add link to pdf acrobat; convert a word document to pdf with hyperlinks
var factorial = function(x) {
if (x <= 1) return 1;
return x * arguments.callee(x-1);
};
8.3.3  Using Object Properties As Arguments
When a function has more than three parameters, it becomes difficult for the pro-
grammer who invokes the function to remember the correct order in which to pass
arguments. To save the programmer the trouble of consulting the documentation each
time she uses the function, it can be nice to allow arguments to be passed as name/
value pairs in any order. To implement this style of method invocation, define your
function to expect a single object as its argument and then have users of the function
pass an object that defines the required name/value pairs. The following code gives an
example and also demonstrates that this style of function invocation allows the function
to specify defaults for any arguments that are omitted:
// Copy length elements of the array from to the array to.
// Begin copying with element from_start in the from array
// and copy that element to to_start in the to array.
// It is hard to remember the order of the arguments.
function arraycopy(/* array */ from, /* index */ from_start,
/* array */ to,   /* index */ to_start,
/* integer */ length)
{
// code goes here
}
// This version is a little less efficient, but you don't have to
// remember the order of the arguments, and from_start and to_start
// default to 0.
function easycopy(args) {
arraycopy(args.from,
args.from_start || 0,  // Note default value provided
args.to,
args.to_start || 0,
args.length);
}
// Here is how you might invoke easycopy():
var a = [1,2,3,4], b = [];
easycopy({from: a, to: b, length: 4});
8.3.4  Argument Types
JavaScript method parameters have no declared types, and no type checking is
performed on the values you pass to a function. You can help to make your code self-
documenting by choosing descriptive names for function arguments and also by in-
cluding argument types in comments, as in the 
arraycopy()
method just shown. For
arguments that are optional, you can include the word “optional” in the comment. And
when a method can accept any number of arguments, you can use an ellipsis:
function max(/* number... */) { /* code here */ }
174 | Chapter 8: Functions
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. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
add a link to a pdf in acrobat; add hyperlink to pdf in
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Embed PDF hyperlinks to HTML links. How to Use C#.NET Demo Code to Convert PDF Document to HTML5 Files in C#.NET Class. Add necessary references:
add links to pdf document; add a link to a pdf
As described in §3.8, JavaScript performs liberal type conversion as needed. So if you
write a function that expects a string argument and then call that function with a value
of some other type, the value you passed will simply be converted to a string when the
function tries to use it as a string. All primitive types can be converted to strings, and
all objects have 
toString()
methods (if not necessarily useful ones), so an error never
occurs in this case.
This is not always true, however. Consider again the 
arraycopy()
method shown earlier.
It expects an array as its first argument. Any plausible implementation will fail if that
first argument is anything but an array (or possibly an array-like object). Unless you
are writing a “throwaway” function that will be called only once or twice, it may be
worth adding code to check the types of arguments like this. It is better for a function
to fail immediately and predictably when passed bad values than to begin executing
and fail later with an error message that is likely to be unclear. Here is an example
function that performs type-checking. Note that it uses the 
isArrayLike()
function
from §7.11:
// Return the sum of the elements of array (or array-like object) a.
// The elements of a must all be numbers or null and undefined are ignored.
function sum(a) {
if (isArrayLike(a)) {
var total = 0;
for(var i = 0; i < a.length; i++) {  // Loop though all elements
var element = a[i];
if (element == null) continue;   // Skip null and undefined
if (isFinite(element)) total += element;
else throw new Error("sum(): elements must be finite numbers");
}
return total;
}
else throw new Error("sum(): argument must be array-like");
}
This 
sum()
method is fairly strict about the argument it accepts and throws suitably
informative errors if it is passed bad values. It does offer a bit of flexibility, however,
by working with array-like objects as well as true arrays and by ignoring 
null
and
undefined
array elements.
JavaScript is a very flexible and loosely typed language, and sometimes it is appropriate
to write functions that are flexible about the number and type of arguments they are
passed. The following 
flexisum()
method takes this approach (probably to an ex-
treme). For example, it accepts any number of arguments but recursively processes any
arguments that are arrays. In this way, it can be used as a varargs method or with an
array argument. Furthermore, it tries its best to convert nonnumeric values to numbers
before throwing an error:
function flexisum(a) {
var total = 0;
for(var i = 0; i < arguments.length; i++) {
var element = arguments[i], n;
if (element == null) continue;  // Ignore null and undefined arguments
8.3  Function Arguments and Parameters | 175
Core JavaScript
VB.NET PDF Page Replace Library: replace PDF pages in C#.net, ASP.
all PDF page contents in VB.NET, including text, image, hyperlinks, etc. Replace a Page (in a PDFDocument Object) by a PDF Page Object. Add necessary references:
accessible links in pdf; add hyperlink pdf document
VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in
PDF document is an easy work and gives quick access to PDF page and file, or even hyperlinks. How to VB.NET: Create Thumbnail for PDF. Add necessary references:
add hyperlink to pdf in preview; pdf email link
if (isArray(element))                   // If the argument is an array 
n = flexisum.apply(this, element);  // compute its sum recursively
else if (typeof element === "function") // Else if it's a function...
n = Number(element());              // invoke it and convert.
else n = Number(element);               // Else try to convert it 
if (isNaN(n))  // If we couldn't convert to a number, throw an error
throw Error("flexisum(): can't convert " + element + " to number");
total += n;    // Otherwise, add n to the total
}
return total;  
}
8.4  Functions As Values
The most important features of functions are that they can be defined and invoked.
Function definition and invocation are syntactic features of JavaScript and of most
other programming languages. In JavaScript, however, functions are not only syntax
but also values, which means they can be assigned to variables, stored in the properties
of objects or the elements of arrays, passed as arguments to functions, and so on.
3
To understand how functions can be JavaScript data as well as JavaScript syntax, con-
sider this function definition:
function square(x) { return x*x; }
This definition creates a new function object and assigns it to the variable 
square
. The
name of a function is really immaterial; it is simply the name of a variable that refers to
the function object. The function can be assigned to another variable and still work the
same way:
var s = square;     // Now s refers to the same function that square does
square(4);          // => 16
s(4);               // => 16
Functions can also be assigned to object properties rather than variables. When you
do this, they’re called methods:
var o = {square: function(x) { return x*x; }}; // An object literal
var y = o.square(16);                          // y equals 256
Functions don’t even require names at all, as when they’re assigned to array elements:
var a = [function(x) { return x*x; }, 20];   // An array literal
a[0](a[1]);                                  // => 400
The syntax of this last example looks strange, but it is still a legal function invocation
expression!
3.This may not seem like a particularly interesting point unless you are familiar with languages such as Java,
in which functions are part of a program but cannot be manipulated by the program.
176 | Chapter 8: Functions
.NET PDF SDK | Read & Processing PDF files
by this .NET Imaging PDF Reader Add-on. Include extraction of text, hyperlinks, bookmarks and metadata; Annotate and redact in PDF documents; Fully support all
add links to pdf file; pdf link
PDF Image Viewer| What is PDF
advanced capabilities, such as text extraction, hyperlinks, bookmarks and Note: PDF processing and conversion is excluded in NET Imaging SDK, you may add it on
pdf link open in new window; check links in pdf
Example 8-2 demonstrates the kinds of things that can be done when functions are
used as values. This example may be a little tricky, but the comments explain what is
going on.
Example 8-2. Using functions as data
// We define some simple functions here
function add(x,y) { return x + y; }
function subtract(x,y) { return x - y; }
function multiply(x,y) { return x * y; }
function divide(x,y) { return x / y; }
// Here's a function that takes one of the above functions
// as an argument and invokes it on two operands
function operate(operator, operand1, operand2) {
return operator(operand1, operand2);
}
// We could invoke this function like this to compute the value (2+3) + (4*5):
var i = operate(add, operate(add, 2, 3), operate(multiply, 4, 5));
// For the sake of the example, we implement the simple functions again, 
// this time using function literals within an object literal;
var operators = {
add:      function(x,y) { return x+y; },
subtract: function(x,y) { return x-y; },
multiply: function(x,y) { return x*y; },
divide:   function(x,y) { return x/y; },
pow:      Math.pow  // Works for predefined functions too
};
// This function takes the name of an operator, looks up that operator
// in the object, and then invokes it on the supplied operands. Note
// the syntax used to invoke the operator function.
function operate2(operation, operand1, operand2) {
if (typeof operators[operation] === "function")
return operators[operation](operand1, operand2);
else throw "unknown operator";
}
// Compute the value ("hello" + " " + "world") like this:
var j = operate2("add", "hello", operate2("add", " ", "world"));
// Using the predefined Math.pow() function:
var k = operate2("pow", 10, 2);
As another example of functions as values, consider the 
Array.sort()
method. This
method sorts the elements of an array. Because there are many possible orders to sort
by (numerical order, alphabetical order, date order, ascending, descending, and so on),
the 
sort()
method optionally takes a function as an argument to tell it how to perform
the sort. This function has a simple job: for any two values it is passed, it returns a value
that specifies which element would come first in a sorted array. This function argument
makes 
Array.sort()
perfectly general and infinitely flexible; it can sort any type of data
into any conceivable order. Examples are shown in §7.8.3.
8.4  Functions As Values | 177
Core JavaScript
8.4.1  Defining Your Own Function Properties
Functions are not primitive values in JavaScript, but a specialized kind of object, which
means that functions can have properties. When a function needs a “static” variable
whose value persists across invocations, it is often convenient to use a property of the
function, instead of cluttering up the namespace by defining a global variable. For
example, suppose you want to write a function that returns a unique integer whenever
it is invoked. The function must never return the same value twice. In order to manage
this, the function needs to keep track of the values it has already returned, and this
information must persist across function invocations. You could store this information
in a global variable, but that is unnecessary, because the information is used only by
the function itself. It is better to store the information in a property of the Function
object. Here is an example that returns a unique integer whenever it is called:
// Initialize the counter property of the function object.
// Function declarations are hoisted so we really can 
// do this assignment before the function declaration.
uniqueInteger.counter = 0;
// This function returns a different integer each time it is called.
// It uses a property of itself to remember the next value to be returned.
function uniqueInteger() {
return uniqueInteger.counter++;  // Increment and return counter property
}
As another example, consider the following 
factorial()
function that uses properties
of itself (treating itself as an array) to cache previously computed results:
// Compute factorials and cache results as properties of the function itself.
function factorial(n) {
if (isFinite(n) && n>0 && n==Math.round(n)) { // Finite, positive ints only
if (!(n in factorial))                    // If no cached result
factorial[n] = n * factorial(n-1);    // Compute and cache it
return factorial[n];                      // Return the cached result
}
else return NaN;                              // If input was bad
}
factorial[1] = 1;  // Initialize the cache to hold this base case.
8.5  Functions As Namespaces
Recall from §3.10.1 that JavaScript has function scope: variables declared within a
function are visible throughout the function (including within nested functions) but
do not exist outside of the function. Variables declared outside of a function are global
variables and are visible throughout your JavaScript program. JavaScript does not de-
fine any way to declare variables that are hidden within a single block of code, and for
this reason, it is sometimes useful to define a function simply to act as a temporary
namespace in which you can define variables without polluting the global namespace.
178 | Chapter 8: Functions
Suppose, for example, you have a module of JavaScript code that you want to use in a
number of different JavaScript programs (or, for client-side JavaScript, on a number of
different web pages). Assume that this code, like most code, defines variables to store
the intermediate results of its computation. The problem is that since this module will
be used in many different programs, you don’t know whether the variables it creates
will conflict with variables used by the programs that import it. The solution, of course,
is to put the code into a function and then invoke the function. This way, variables that
would have been global become local to the function:
function mymodule() {
// Module code goes here.
// Any variables used by the module are local to this function
// instead of cluttering up the global namespace.
}
mymodule();  // But don't forget to invoke the function!
This code defines only a single global variable: the function name “mymodule”. If de-
fining even a single property is too much, you can define and invoke an anonymous
function in a single expression:
(function() {  // mymodule function rewritten as an unnamed expression
// Module code goes here.
}());          // end the function literal and invoke it now.
This technique of defining and invoking a function in a single expression is used fre-
quently enough that it has become idiomatic. Note the use of parentheses in the code
above. The open parenthesis before 
function
is required because without it, the Java-
Script interpreter tries to parse the 
function
keyword as a function declaration state-
ment. With the parenthesis, the interpreter correctly recognizes this as a function
definition expression. It is idiomatic to use the parentheses, even when they are not
required, around a function that is to be invoked immediately after being defined.
Example 8-3 demonstrates this namespace technique. It defines an anonymous func-
tion that returns an 
extend()
function like the one shown in Example 6-2. The code in
the anonymous function tests whether a well-known Internet Explorer bug is present
and, if so, returns a patched version of the function. In addition, the anonymous func-
tion’s namespace serves to hide an array of property names.
Example 8-3. The extend() function, patched if necessary
// Define an extend function that copies the properties of its second and 
// subsequent arguments onto its first argument.
// We work around an IE bug here: in many versions of IE, the for/in loop
// won't enumerate an enumerable property of o if the prototype of o has 
// a nonenumerable property by the same name. This means that properties
// like toString are not handled correctly unless we explicitly check for them.
var extend = (function() {  // Assign the return value of this function 
// First check for the presence of the bug before patching it.
for(var p in {toString:null}) {
// If we get here, then the for/in loop works correctly and we return
// a simple version of the extend() function
return function extend(o) {
8.5  Functions As Namespaces | 179
Core JavaScript
for(var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for(var prop in source) o[prop] = source[prop];
}
return o;
};
}
// If we get here, it means that the for/in loop did not enumerate
// the toString property of the test object. So return a version
// of the extend() function that explicitly tests for the nonenumerable
// properties of Object.prototype.
return function patched_extend(o) {
for(var i = 1; i < arguments.length; i++) {
var source = arguments[i];
// Copy all the enumerable properties
for(var prop in source) o[prop] = source[prop];
// And now check the special-case properties
for(var j = 0; j < protoprops.length; j++) {
prop = protoprops[j];
if (source.hasOwnProperty(prop)) o[prop] = source[prop];
}
}
return o;
};
// This is the list of special-case properties we check for
var protoprops = ["toString", "valueOf", "constructor", "hasOwnProperty",
"isPrototypeOf", "propertyIsEnumerable","toLocaleString"];
}());
8.6  Closures
Like most modern programming languages, JavaScript uses lexical scoping. This means
that functions are executed using the variable scope that was in effect when they were
defined, not the variable scope that is in effect when they are invoked. In order to
implement lexical scoping, the internal state of a JavaScript function object must in-
clude not only the code of the function but also a reference to the current scope chain.
(Before reading the rest of this section, you may want to review the material on variable
scope and the scope chain in §3.10 and §3.10.3.) This combination of a function object
and a scope (a set of variable bindings) in which the function’s variables are resolved
is called a closure in the computer science literature.
4
Technically, all JavaScript functions are closures: they are objects, and they have a scope
chain associated with them. Most functions are invoked using the same scope chain
that was in effect when the function was defined, and it doesn’t really matter that there
is a closure involved. Closures become interesting when they are invoked under a
4.This is an old term that refers to the fact that the function’s variables have bindings in the scope chain
and that therefore the function is “closed over” its variables.
180 | Chapter 8: Functions
different scope chain than the one that was in effect when they were defined. This
happens most commonly when a nested function object is returned from the function
within which it was defined. There are a number of powerful programming techniques
that involve this kind of nested function closures, and their use has become relatively
common in JavaScript programming. Closures may seem confusing when you first en-
counter them, but it is important that you understand them well enough to use them
comfortably.
The first step to understanding closures is to review the lexical scoping rules for nested
functions. Consider the following code (which is similar to code you’ve already seen
in §3.10):
var scope = "global scope";          // A global variable
function checkscope() {
var scope = "local scope";       // A local variable
function f() { return scope; }   // Return the value in scope here
return f();
}
checkscope()                         // => "local scope"
The 
checkscope()
function declares a local variable and then defines and invokes a
function that returns the value of that variable. It should be clear to you why the call
to 
checkscope()
returns “local scope”. Now let’s change the code just slightly. Can you
tell what this code will return?
var scope = "global scope";          // A global variable
function checkscope() {
var scope = "local scope";       // A local variable
function f() { return scope; }   // Return the value in scope here
return f;
}
checkscope()()                       // What does this return?
In this code, a pair of parentheses has moved from inside 
checkscope()
to outside of it.
Instead of invoking the nested function and returning its result, 
checkscope()
now just
returns the nested function object itself. What happens when we invoke that nested
function (with the second pair of parentheses in the last line of code) outside of the
function in which it was defined?
Remember the fundamental rule of lexical scoping: JavaScript functions are executed
using the scope chain that was in effect when they were defined. The nested function
f()
was defined under a scope chain in which the variable 
scope
was bound to the value
“local scope”. That binding is still in effect when 
f
is executed, wherever it is executed
from. So the last line of code above returns “local scope”, not “global scope”. This, in
a nutshell, is the surprising and powerful nature of closures: they capture the local
variable (and parameter) bindings of the outer function within which they are defined.
8.6  Closures | 181
Core JavaScript
Implementing Closures
Closures are easy to understand if you simply accept the lexical scoping rule: functions
are executed using the scope chain that was in effect when they were defined. Some
programmers find closures confusing, however, because they get caught up in imple-
mentation details. Surely, they think, the local variables defined in the outer function
cease to exist when the outer function returns, so how can the nested function execute
using a scope chain that does not exist anymore? If you’re wondering about this your-
self, then you have probably been exposed to low-level programming languages like C
and to stack-based CPU architectures: if a function’s local variables are defined on a
CPU stack, then they would indeed cease to exist when the function returned.
But remember our definition of scope chain from §3.10.3. We described it as a list of
objects, not a stack of bindings. Each time a JavaScript function is invoked, a new object
is created to hold the local variables for that invocation, and that object is added to the
scope chain. When the function returns, that variable binding object is removed from
the scope chain. If there were no nested functions, there are no more references to the
binding object and it gets garbage collected. If there were nested functions defined,
then each of those functions has a reference to the scope chain, and that scope chain
refers to the variable binding object. If those nested functions objects remained within
their outer function, however, then they themselves will be garbage collected, along
with the variable binding object they referred to. But if the function defines a nested
function and returns it or stores it into a property somewhere, then there will be an
external reference to the nested function. It won’t be garbage collected, and the variable
binding object it refers to won’t be garbage collected either.
In §8.4.1 we defined a 
uniqueInteger()
function that used a property of the function
itself to keep track of the next value to be returned. A shortcoming of that approach is
that buggy or malicious code could reset the counter or set it to a noninteger, causing
the 
uniqueInteger()
function to violate the “unique” or the “integer” part of its con-
tract. Closures capture the local variables of a single function invocation and can use
those variables as private state. Here is how we could rewrite the 
uniqueInteger()
function using closures:
var uniqueInteger = (function() {          // Define and invoke
var counter = 0;  // Private state of function below
return function() { return counter++; };
}());
In order to understand this code, you have to read it carefully. At first glance, the first
line of code looks like it is assigning a function to the variable 
uniqueInteger
. In fact,
the code is defining and invoking (as hinted by the open parenthesis on the first line)
a function, so it is the return value of the function that is being assigned to
uniqueInteger
. Now, if we study the body of the function, we see that its return value
is another  function.  It  is this  nested  function object that gets  assigned to
uniqueInteger
. The nested function has access to the variables in scope, and can use
the 
counter
variable defined in the outer function. Once that outer function returns,
no other code can see the 
counter
variable: the inner function has exclusive access to it.
182 | Chapter 8: Functions
Documents you may be interested
Documents you may be interested