open pdf and draw c# : Add a link to a pdf file Library SDK component asp.net .net web page mvc %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D17-part1545

7.9  ECMAScript 5 Array Methods
ECMAScript 5 defines nine new array methods for iterating, mapping, filtering, testing,
reducing, and searching arrays. The subsections below describe these methods.
Before we cover the details, however, it is worth making some generalizations about
these ECMAScript 5 array methods. First, most of the methods accept a function as
their first argument and invoke that function once for each element (or some elements)
of the array. If the array is sparse, the function you pass is not invoked for nonexistent
elements. In most cases, the function you supply is invoked with three arguments: the
value of the array element, the index of the array element, and the array itself. Often,
you only need the first of these argument values and can ignore the second and third
values. Most of the ECMAScript 5 array methods that accept a function as their first
argument accept an optional second argument. If specified, the function is invoked as
if it is a method of this second argument. That is, the second argument you pass be-
comes the value of the 
this
keyword inside of the function you pass. The return value
of the function you pass is important, but different methods handle the return value in
different ways. None of the ECMAScript 5 array methods modify the array on which
they are invoked. If you pass a function to these methods, that function may modify
the array, of course.
7.9.1  forEach()
The 
forEach()
method iterates through an array, invoking a function you specify for
each element. As described above, you pass the function as the first argument to
forEach()
forEach()
then invokes your function with three arguments: the value of the
array element, the index of the array element, and the array itself. If you only care about
the value of the array element, you can write a function with only one parameter—the
additional arguments will be ignored:
var data = [1,2,3,4,5];                           // An array to sum
// Compute the sum of the array elements
var sum = 0;                                      // Start at 0
data.forEach(function(value) { sum += value; });  // Add each value to sum
sum                                               // => 15
// Now increment each array element
data.forEach(function(v, i, a) { a[i] = v + 1; });
data                                              // => [2,3,4,5,6]
Note that 
forEach()
does not provide a way to terminate iteration before all elements
have been passed to the function. That is, there is no equivalent of the 
break
statement
you can use with a regular 
for
loop. If you need to terminate early, you must throw an
exception, and place the call to 
forEach()
within a 
try
block. The following code defines
foreach()
function that calls the 
forEach()
method within such a try block. If the
function passed to 
foreach()
throws 
foreach.break
, the loop will terminate early:
function foreach(a,f,t) {
try { a.forEach(f,t); }
7.9  ECMAScript 5 Array Methods | 153
Core JavaScript
Add a link to a pdf file - 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 hyperlinks to pdf; active links in pdf
Add a link to a pdf file - 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
clickable links in pdf; add hyperlink pdf file
catch(e) {
if (e === foreach.break) return; 
else throw e;
}
}
foreach.break = new Error("StopIteration");
7.9.2  map()
The 
map()
method passes each element of the array on which it is invoked to the function
you specify, and returns an array containing the values returned by that function. For
example:
a = [1, 2, 3];
b = a.map(function(x) { return x*x; });  // b is [1, 4, 9]
The function you pass to 
map()
is invoked in the same way as a function passed to
forEach()
. For the 
map()
method, however, the function you pass should return a value.
Note that 
map()
returns a new array: it does not modify the array it is invoked on. If
that array is sparse, the returned array will be sparse in the same way: it will have the
same length and the same missing elements.
7.9.3  filter()
The 
filter()
method returns an array containing a subset of the elements of the array
on which it is invoked. The function you pass to it should be predicate: a function that
returns 
true
or 
false
. The predicate is invoked just as for 
forEach()
and 
map()
. If the
return value is 
true
, or a value that converts to 
true
, then the element passed to the
predicate is a member of the subset and is added to the array that will become the return
value. Examples:
a = [5, 4, 3, 2, 1];
smallvalues = a.filter(function(x) { return x < 3 });   // [2, 1]
everyother = a.filter(function(x,i) { return i%2==0 }); // [5, 3, 1]
Note that 
filter()
skips missing elements in sparse arrays, and that its return value is
always dense. To close the gaps in a sparse array, you can do this:
var dense = sparse.filter(function() { return true; });
And to close gaps and remove undefined and null elements you can use 
filter
like this:
a = a.filter(function(x) { return x !== undefined && x != null; });
7.9.4  every() and some()
The 
every()
and 
some()
methods are array predicates: they apply a predicate function
you specify to the elements of the array, and then return 
true
or 
false
.
The 
every()
method is like the mathematical “for all” quantifier ∀: it returns 
true
if
and only if your predicate function returns 
true
for all elements in the array:
154 | Chapter 7: Arrays
C# PDF Library SDK to view, edit, convert, process PDF file for C#
and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update, and delete PDF file metadata, like
add hyperlink to pdf in preview; adding links to pdf
VB.NET PDF Password Library: add, remove, edit PDF file password
This VB.NET example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = True ' Add password to PDF file.
add a link to a pdf file; add hyperlinks to pdf online
a = [1,2,3,4,5];
a.every(function(x) { return x < 10; })      // => true: all values < 10.
a.every(function(x) { return x % 2 === 0; }) // => false: not all values even.
The 
some()
method is like the mathematical “there exists” quantifier ∃: it returns
true
if there exists at least one element in the array for which the predicate returns
true
, and returns 
false
if and only if the predicate returns 
false
for all elements of
the array:
a = [1,2,3,4,5];
a.some(function(x) { return x%2===0; })  // => true a has some even numbers.
a.some(isNaN)                            // => false: a has no non-numbers.
Note that both 
every()
and 
some()
stop iterating array elements as soon as they know
what value to return. 
some()
returns 
true
the first time your predicate returns true, and
only iterates through the entire array if your predicate always returns 
false
every()
is
the opposite: it returns 
false
the first time your predicate returns 
false
, and only iter-
ates all elements if your predicate always returns 
true
. Note also that by mathematical
convention, 
every()
returns 
true
and 
some
returns 
false
when invoked on an empty
array.
7.9.5  reduce(), reduceRight()
The 
reduce()
and 
reduceRight()
methods combine the elements of an array, using the
function you specify, to produce a single value. This is a common operation in func-
tional programming and also goes by the names “inject” and “fold.” Examples help
illustrate how it works:
var a = [1,2,3,4,5]
var sum = a.reduce(function(x,y) { return x+y }, 0);     // Sum of values
var product = a.reduce(function(x,y) { return x*y }, 1); // Product of values
var max = a.reduce(function(x,y) { return (x>y)?x:y; }); // Largest value
reduce()
takes two arguments. The first is the function that performs the reduction
operation. The task of this reduction function is to somehow combine or reduce two
values into a single value, and to return that reduced value. In the examples above, the
functions combine two values by adding them, multiplying them, and choosing the
largest. The second (optional) argument is an initial value to pass to the function.
Functions used with 
reduce()
are different than the functions used with 
forEach()
and
map()
. The familiar value, index, and array values are passed as the second, third, and
fourth arguments. The first argument is the accumulated result of the reduction so far.
On the first call to the function, this first argument is the initial value you passed as the
second argument to 
reduce()
. On subsequent calls, it is the value returned by the pre-
vious invocation of the function. In the first example above, the reduction function is
first called with arguments 0 and 1. It adds these and returns 1. It is then called again
with arguments 1 and 2 and it returns 3. Next it computes 3+3=6, then 6+4=10, and
finally 10+5=15. This final value, 15, becomes the return value of 
reduce()
.
7.9  ECMAScript 5 Array Methods | 155
Core JavaScript
C# PDF Password Library: add, remove, edit PDF file password in C#
This example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = true; // Add password to PDF file.
change link in pdf file; pdf email link
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Insert Image to PDF. Image: Remove Image from PDF Page. Copy, Paste, Cut Image in Page. Link: Edit URL. Images. Redact Pages. Annotation & Drawing. Add Sticky Note
clickable pdf links; change link in pdf
You may have noticed that the third call to 
reduce()
above has only a single argument:
there is no initial value specified. When you invoke 
reduce()
like this with no initial
value, it uses the first element of the array as the initial value. This means that the
first call to the reduction function will have the first and second array elements as its
first and second arguments. In the sum and product examples above, we could have
omitted the initial value argument.
Calling 
reduce()
on an empty array with no initial value argument causes a TypeError.
If you call it with only one value—either an array with one element and no initial value
or an empty array and an initial value—it simply returns that one value without ever
calling the reduction function.
reduceRight()
works just like 
reduce()
, except that it processes the array from highest
index to lowest (right-to-left), rather than from lowest to highest. You might want to
do this if the reduction operation has right-to-left precedence, for example:
var a = [2, 3, 4]
// Compute 2^(3^4).  Exponentiation has right-to-left precedence
var big = a.reduceRight(function(accumulator,value) {
return Math.pow(value,accumulator);
});
Note that neither 
reduce()
nor 
reduceRight()
accepts an optional argument that speci-
fies the 
this
value on which the reduction function is to be invoked. The optional initial
value argument takes its place. See the 
Function.bind()
method if you need your re-
duction function invoked as a method of a particular object.
It is worth noting that the 
every()
and 
some()
methods described above perform a kind
of array reduction operation. They differ from 
reduce()
, however, in that they terminate
early when possible, and do not always visit every array element.
The examples shown so far have been numeric for simplicity, but 
reduce()
and 
reduce
Right()
are  not  intended  solely  for  mathematical  computations.  Consider  the
union()
function from Example 6-2. It computes the “union” of two objects and returns
a new object that has the properties of both. This function expects two objects and
returns another object, so it works as a reduction function, and we can use 
reduce()
to
generalize it and compute the union of any number of objects:
var objects = [{x:1}, {y:2}, {z:3}];
var merged = objects.reduce(union);    // => {x:1, y:2, z:3}
Recall that when two objects have properties with the same name, the 
union()
function
uses the value of that property from the first argument. Thus 
reduce()
and 
reduce
Right()
may give different results when used with 
union()
:
var objects = [{x:1,a:1}, {y:2,a:2}, {z:3,a:3}];
var leftunion = objects.reduce(union);       // {x:1, y:2, z:3, a:1}
var rightunion = objects.reduceRight(union); // {x:1, y:2, z:3, a:3}
156 | Chapter 7: Arrays
C# PDF insert image Library: insert images into PDF in C#.net, ASP
using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; Have a try with this sample C#.NET code to add an image to the first page of PDF file.
pdf link to specific page; convert excel to pdf with hyperlinks
VB.NET PDF insert image library: insert images into PDF in vb.net
using RasterEdge.XDoc.PDF; Have a try with this sample VB.NET code to add an image to the first page of PDF file. ' Open a document.
add hyperlinks pdf file; pdf link
7.9.6  indexOf() and lastIndexOf()
indexOf()
and 
lastIndexOf()
search an array for an element with a specified value, and
return the index of the first such element found, or –1 if none is found. 
indexOf()
searches the array from beginning to end, and 
lastIndexOf()
searches from end to
beginning.
a = [0,1,2,1,0];
a.indexOf(1)       // => 1: a[1] is 1
a.lastIndexOf(1)   // => 3: a[3] is 1
a.indexOf(3)       // => -1: no element has value 3
Unlike the other methods described in this section, 
indexOf()
and 
lastIndexOf()
do
not take a function argument. The first argument is the value to search for. The second
argument is optional: it specifies the array index at which to begin the search. If this
argument is omitted, 
indexOf()
starts at the beginning and 
lastIndexOf()
starts at the
end. Negative values are allowed for the second argument and are treated as an offset
from the end of the array, as they are for the 
splice()
method: a value of –1, for example,
specifies the last element of the array.
The following function searches an array for a specified value and returns an array of
all matching indexes. This demonstrates how the second argument to 
indexOf()
can
be used to find matches beyond the first.
// Find all occurrences of a value x in an array a and return an array
// of matching indexes
function findall(a, x) {
var results = [],            // The array of indexes we'll return
len = a.length,          // The length of the array to be searched
pos = 0;                 // The position to search from
while(pos < len) {           // While more elements to search...
pos = a.indexOf(x, pos); // Search
if (pos === -1) break;   // If nothing found, we're done.
results.push(pos);       // Otherwise, store index in array
pos = pos + 1;           // And start next search at next element
}
return results;              // Return array of indexes
}
Note that strings have 
indexOf()
and 
lastIndexOf()
methods that work like these array
methods.
7.10  Array Type
We’ve seen throughout this chapter that arrays are objects with some special behavior.
Given an unknown object, it is often useful to be able to determine whether it is an
array or not. In ECMAScript 5, you can do this with the 
Array.isArray()
function:
Array.isArray([])     // => true
Array.isArray({})     // => false
7.10  Array Type | 157
Core JavaScript
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# of PDF document, including editing PDF url links and quick navigation link in bookmark
add hyperlink to pdf acrobat; pdf link to attached file
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
Add necessary references: using RasterEdge.XDoc.PDF; Note: When you get the error "Could not load file or assembly 'RasterEdge.Imaging.Basic' or any other
add link to pdf; adding links to pdf document
Prior to ECMAScript 5, however, distinguishing arrays from nonarray objects was sur-
prisingly difficult. The 
typeof
operator does not help here: it returns “object” for arrays
(and for all objects other than functions). The 
instanceof
operator works in simple
cases:
[] instanceof Array     // => true
({}) instanceof Array   // => false
The problem with using 
instanceof
is that in web browsers, there can be more than
one window or frame open. Each has its own JavaScript environment, with its own
global object. And each global object has its own set of constructor functions. Therefore
an object from one frame will never be an instance of a constructor from another frame.
While interframe confusion does not arise often, it is enough of a problem that the
instanceof
operator is not deemed a reliable test for arrays.
The solution is to inspect the class attribute (see §6.8.2) of the object. For arrays, this
attribute will always have the value “Array”, and we can therefore write an 
isArray()
function in ECMAScript 3 like this:
var isArray = Function.isArray || function(o) {
return typeof o === "object" &&
Object.prototype.toString.call(o) === "[object Array]";
};
This  test  of  the  class  attribute  is,  in  fact,  exactly  what  the  ECMAScript  5
Array.isArray()
function does. The technique for obtaining the class of an object using
Object.prototype.toString()
is explained in §6.8.2 and demonstrated in Example 6-4.
7.11  Array-Like Objects
As we’ve seen, JavaScript arrays have some special features that other objects do
not have:
• The 
length
property is automatically updated as new elements are added to the list.
• Setting 
length
to a smaller value truncates the array.
• Arrays inherit useful methods from 
Array.prototype
.
• Arrays have a class attribute of “Array”.
These are the features that make JavaScript arrays distinct from regular objects. But
they are not the essential features that define an array. It is often perfectly reasonable
to treat any object with a numeric 
length
property and corresponding non-negative
integer properties as a kind of array.
These “array-like” objects actually do occasionally appear in practice, and although
you cannot directly invoke array methods on them or expect special behavior from the
length
property, you can still iterate through them with the same code you’d use for a
true array. It turns out that many array algorithms work just as well with array-like
158 | Chapter 7: Arrays
objects as they do with real arrays. This is especially true if your algorithms treat the
array as read-only or if they at least leave the array length unchanged.
The following code takes a regular object, adds properties to make it an array-like
object, and then iterates through the “elements” of the resulting pseudo-array:
var a = {};  // Start with a regular empty object
// Add properties to make it "array-like"
var i = 0;
while(i < 10) {
a[i] = i * i;
i++;
}
a.length = i;
// Now iterate through it as if it were a real array
var total = 0;
for(var j = 0; j < a.length; j++)
total += a[j];
The Arguments object that’s described in §8.3.2 is an array-like object. In client-side
JavaScript, a number of DOM methods, such as 
document.getElementsByTagName()
,
return array-like objects. Here’s a function you might use to test for objects that work
like arrays:
// Determine if o is an array-like object.
// Strings and functions have numeric length properties, but are 
// excluded by the typeof test. In client-side JavaScript, DOM text
// nodes have a numeric length property, and may need to be excluded 
// with an additional o.nodeType != 3 test.
function isArrayLike(o) {
if (o &&                                // o is not null, undefined, etc.
typeof o === "object" &&            // o is an object
isFinite(o.length) &&               // o.length is a finite number
o.length >= 0 &&                    // o.length is non-negative
o.length===Math.floor(o.length) &&  // o.length is an integer
o.length < 4294967296)              // o.length < 2^32
return true;                        // Then o is array-like
else
return false;                       // Otherwise it is not
}
We’ll see in §7.12 that ECMAScript 5 strings behave like arrays (and that some brows-
ers made strings indexable before ECMAScript 5). Nevertheless, tests like the one above
for array-like objects typically return 
false
for strings—they are usually best handled
as strings, not as arrays.
The JavaScript array methods are purposely defined to be generic, so that they work
correctly  when  applied  to  array-like  objects  in  addition  to  true  arrays.  In
ECMAScript 5, all array methods are generic. In ECMAScript 3, all methods except
toString()
and 
toLocaleString()
are generic. (The 
concat()
method is an exception:
although it can be invoked on an array-like object, it does not property expand that
object  into  the  returned  array.)  Since  array-like  objects  do  not  inherit  from
7.11  Array-Like Objects | 159
Core JavaScript
Array.prototype
, you cannot invoke array methods on them directly. You can invoke
them indirectly using the 
Function.call
method, however:
var a = {"0":"a", "1":"b", "2":"c", length:3};  // An array-like object
Array.prototype.join.call(a, "+")  // => "a+b+c"
Array.prototype.slice.call(a, 0)   // => ["a","b","c"]: true array copy
Array.prototype.map.call(a, function(x) { 
return x.toUpperCase();
})                                 // => ["A","B","C"]:
We’ve seen this 
call()
technique before in the 
isArray()
method of §7.10. The
call()
method of Function objects is covered in more detail in §8.7.3.
The ECMAScript 5 array methods were introduced in Firefox 1.5. Because they were
written generically, Firefox also introduced versions of these methods as functions de-
fined directly on the 
Array
constructor. With these versions of the methods defined,
the examples above can be rewritten like this:
var a = {"0":"a", "1":"b", "2":"c", length:3};  // An array-like object
Array.join(a, "+")
Array.slice(a, 0)
Array.map(a, function(x) { return x.toUpperCase(); })
These static function versions of the array methods are quite useful when working with
array-like objects, but since they are nonstandard, you can’t count on them to be de-
fined in all browsers. You can write code like this to ensure that the functions you need
exist before you use them:
Array.join = Array.join || function(a,sep) {
return Array.prototype.join.call(a,sep);
};
Array.slice = Array.slice || function(a,from,to) {
return Array.prototype.slice.call(a,from,to);
};
Array.map = Array.map || function(a, f, thisArg) {
return Array.prototype.map.call(a, f, thisArg);
}
7.12  Strings As Arrays
In ECMAScript 5 (and in many recent browser implementations—including IE8—
prior to ECMAScript 5), strings behave like read-only arrays. Instead of accessing in-
dividual characters with the 
charAt()
method, you can use square brackets:
var s = test;
s.charAt(0)    // => "t"
s[1]           // => "e"
The 
typeof
operator  still  returns  “string”  for  strings,  of  course,  and  the
Array.isArray()
method returns 
false
if you pass it a string.
The  primary  benefit of  indexable  strings is  simply  that  we  can  replace  calls  to
charAt()
with square brackets, which are more concise and readable, and potentially
160 | Chapter 7: Arrays
more efficient. The fact that strings behave like arrays also means, however, that we
can apply generic array methods to them. For example:
s = "JavaScript"
Array.prototype.join.call(s, " ")      // => "J a v a S c r i p t"
Array.prototype.filter.call(s,         // Filter the characters of the string
function(x) {                      
return x.match(/[^aeiou]/);    // Only match nonvowels
}).join("")                        // => "JvScrpt"
Keep in mind that strings are immutable values, so when they are treated as arrays, they
are read-only arrays. Array methods like 
push()
sort()
reverse()
, and 
splice()
mod-
ify an array in place and do not work on strings. Attempting to modify a string using
an array method does not, however, cause an error: it simply fails silently.
7.12  Strings As Arrays | 161
Core JavaScript
Documents you may be interested
Documents you may be interested