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

value should be inside the brackets. You can use this syntax to both read and write the
value of an element of an array. Thus, the following are all legal JavaScript statements:
var a = ["world"];     // Start with a one-element array
var value = a[0];      // Read element 0
a[1] = 3.14;           // Write element 1
i = 2;         
a[i] = 3;              // Write element 2
a[i + 1] = "hello";    // Write element 3
a[a[i]] = a[0];        // Read elements 0 and 2, write element 3
Remember that arrays are a specialized kind of object. The square brackets used to
access array elements work just like the square brackets used to access object properties.
JavaScript converts the numeric array index you specify to a string—the index 
1
be-
comes the string 
"1"
—then uses that string as a property name. There is nothing special
about the conversion of the index from a number to a string: you can do that with
regular objects, too:
o = {};        // Create a plain object
o[1] = "one";  // Index it with an integer
What is special about arrays is that when you use property names that are non-negative
integers less than 2
32
, the array automatically maintains the value of the 
length
property
for you. Above, for example, we created an array 
a
with a single element. We then
assigned values at indexes 1, 2, and 3. The 
length
property of the array changed as we
did so:
a.length       // => 4
It is helpful to clearly distinguish an array index from an object property name. All
indexes are property names, but only property names that are integers between 0 and
232–1 are indexes. All arrays are objects, and you can create properties of any name on
them. If you use properties that are array indexes, however, arrays have the special
behavior of updating their 
length
property as needed.
Note that you can index an array using numbers that are negative or that are not inte-
gers. When you do this, the number is converted to a string, and that string is used as
the property name. Since the name is not a non-negative integer, it is treated as a regular
object property, not an array index. Also, if you index an array with a string that hap-
pens to be a non-negative integer, it behaves as an array index, not an object property.
The same is true if you use a floating-point number that is the same as an integer:
a[-1.23] = true;  // This creates a property named "-1.23"
a["1000"] = 0;    // This the 1001st element of the array
a[1.000]          // Array index 1.  Same as a[1]
The fact that array indexes are simply a special type of object property name means
that JavaScript arrays have no notion of an “out of bounds” error. When you try to
query a nonexistent property of any object, you don’t get an error, you simply get
undefined
. This is just as true for arrays as it is for objects:
7.2  Reading and Writing Array Elements | 143
Core JavaScript
Adding an email link to a pdf - 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
adding hyperlinks to pdf; pdf edit hyperlink
Adding an email link to a pdf - 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 hyperlink pdf document; add a link to a pdf in acrobat
a = [true, false];     // This array has elements at indexes 0 and 1
a[2]                   // => undefined. No element at this index.
a[-1]                  // => undefined. No property with this name.
Since arrays are objects, they can inherit elements from  their prototype. In
ECMAScript 5, they can even have array elements defined by getter and setter methods
(§6.6). If an array does inherit elements or use getters and setters for elements, you
should expect it to use a nonoptimized code path: the time to access an element of such
an array would be similar to regular object property lookup times.
7.3  Sparse Arrays
A sparse array is one in which the elements do not have contiguous indexes starting at
0. Normally, the 
length
property of an array specifies the number of elements in the
array. If the array is sparse, the value of the 
length
property is greater than the number
of elements. Sparse arrays can be created with the 
Array()
constructor or simply by
assigning to an array index larger than the current array 
length
.
a = new Array(5);   // No elements, but a.length is 5.
a = [];             // Create an array with no elements and length = 0.
a[1000] = 0;        // Assignment adds one element but sets length to 1001.
We’ll see later that you can also make an array sparse with the 
delete
operator.
Arrays that are sufficiently sparse are typically implemented in a slower, more memory-
efficient way than dense arrays are, and looking up elements in such an array will take
about as much time as regular object property lookup.
Note that when you omit value in an array literal, you are not creating a sparse array.
The omitted element exists in the array and has the value 
undefined
. This is subtly
different than array elements that do not exist at all. You can detect the difference
between these two cases with the 
in
operator:
var a1 = [,,,];         // This array is [undefined, undefined, undefined]
var a2 = new Array(3);  // This array has no values at all
0 in a1                 // => true: a1 has an element with index 0
0 in a2                 // => false: a2 has no element with index 0
The difference between 
a1
and 
a2
is also apparent when you use a 
for/in
loop. See §7.6.
Understanding sparse arrays is an important part of understanding the true nature of
JavaScript arrays. In practice, however, most JavaScript arrays you will work with will
not be sparse. And, if you do have to work with a sparse array, your code will probably
treat it just as it would treat a nonsparse array with 
undefined
elements.
7.4  Array Length
Every array has a 
length
property, and it is this property that makes arrays different
from regular JavaScript objects. For arrays that are dense (i.e., not sparse), the 
length
144 | Chapter 7: Arrays
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
Create editable Word file online without email. In order to convert PDF document to Word file using VB your VB.NET class application by adding reference directly
adding an email link to a pdf; adding a link to a pdf
property specifies the number of elements in the array. Its value is one more than the
highest index in the array:
[].length             // => 0: the array has no elements
['a','b','c'].length  // => 3: highest index is 2, length is 3
When an array is sparse, the 
length
property is greater than the number of elements,
and all we can say about it is that 
length
is guaranteed to be larger than the index of
every element in the array. Or, put another way, an array (sparse or not) will never have
an element whose index is greater than or equal to its 
length
. In order to maintain this
invariant, arrays have two special behaviors. The first was described above: if you assign
a value to an array element whose index 
i
is greater than or equal to the array’s current
length
, the value of the 
length
property is set to 
i+1
.
The second special behavior that arrays implement in order to maintain the length
invariant is that if you set the 
length
property to a non-negative integer 
n
smaller than
its current value, any array elements whose index is greater than or equal to 
n
are deleted
from the array:
a = [1,2,3,4,5];     // Start with a 5-element array.
a.length = 3;        // a is now [1,2,3].
a.length = 0;        // Delete all elements.  a is [].
a.length = 5;        // Length is 5, but no elements, like new Array(5)
You can also set the 
length
property of an array to a value larger than its current value.
Doing this does not actually add any new elements to the array, it simply creates a
sparse area at the end of the array.
In ECMAScript 5, you can make the 
length
property of an array read-only with
Object.defineProperty()
(see §6.7):
a = [1,2,3];                               // Start with a 3-element array.
Object.defineProperty(a, "length",         // Make the length property
{writable: false});  // readonly.
a.length = 0;                              // a is unchanged.
Similarly, if you make an array element nonconfigurable, it cannot be deleted. If it
cannot be deleted, then the 
length
property cannot be set to less than the index of the
nonconfigurable element. (See §6.7 and the 
Object.seal()
and 
Object.freeze()
meth-
ods in §6.8.3.)
7.5  Adding and Deleting Array Elements
We’ve already seen the simplest way to add elements to an array: just assign values to
new indexes:
a = []           // Start with an empty array.
a[0] = "zero";   // And add elements to it.
a[1] = "one";
You can also use the 
push()
method to add one or more values to the end of an array:
7.5  Adding and Deleting Array Elements | 145
Core JavaScript
a = [];              // Start with an empty array
a.push("zero")       // Add a value at the end.  a = ["zero"]
a.push("one", "two") // Add two more values.  a = ["zero", "one", "two"]
Pushing a value onto an array 
a
is the same as assigning the value to 
a[a.length]
. You
can use the 
unshift()
method (described in §7.8) to insert a value at the beginning of
an array, shifting the existing array elements to higher indexes.
You can delete array elements with the 
delete
operator, just as you can delete object
properties:
a = [1,2,3];   
delete a[1];   // a now has no element at index 1
1 in a         // => false: no array index 1 is defined 
a.length       // => 3: delete does not affect array length
Deleting an array element is similar to (but subtly different than) assigning 
undefined
to that element. Note that using 
delete
on an array element does not alter the 
length
property and does not shift elements with higher indexes down to fill in the gap that is
left by the deleted property. If you delete an element from an array, the array becomes
sparse.
As we saw above, you can also delete elements from the end of an array simply by setting
the 
length
property to the new desired length. Arrays have a 
pop()
method (it works
with 
push()
) that reduces the length of an array by 1 but also returns the value of the
deleted element. There is also a 
shift()
method (which goes with 
unshift()
) to remove
an element from the beginning of an array. Unlike 
delete
, the 
shift()
method shifts
all elements down to an index one lower than their current index. 
pop()
and 
shift()
are covered in §7.8 and in the reference section.
Finally, 
splice()
is the general-purpose method for inserting, deleting, or replacing
array elements. It alters the 
length
property and shifts array elements to higher or lower
indexes as needed. See §7.8 for details.
7.6  Iterating Arrays
The most common way to loop through the elements of an array is with a 
for
loop
(§5.5.3):
var keys = Object.keys(o);   // Get an array of property names for object o
var values = []              // Store matching property values in this array
for(var i = 0; i < keys.length; i++) {  // For each index in the array
var key = keys[i];                  // Get the key at that index
values[i] = o[key];                 // Store the value in the values array
}
In nested loops, or other contexts where performance is critical, you may sometimes
see this basic array iteration loop optimized so that the array length is only looked up
once rather than on each iteration:
146 | Chapter 7: Arrays
for(var i = 0, len = keys.length; i < len; i++) {
// loop body remains the same
}
These examples assume that the array is dense and that all elements contain valid data.
If this is not the case, you should test the array elements before using them. If you want
to exclude 
null
undefined
, and nonexistent elements, you can write this:
for(var i = 0; i < a.length; i++) {
if (!a[i]) continue;  // Skip null, undefined, and nonexistent elements
// loop body here
}
If you only want to skip undefined and nonexistent elements, you might write:
for(var i = 0; i < a.length; i++) {
if (a[i] === undefined) continue; // Skip undefined + nonexistent elements
// loop body here
}
Finally, if you only want to skip indexes for which no array element exists but still want
to handle existing undefined elements, do this:
for(var i = 0; i < a.length; i++) {
if (!(i in a)) continue ; // Skip nonexistent elements
// loop body here
}
You can also use a 
for/in
loop (§5.5.4) with sparse arrays. This loop assigns enumera-
ble property names (including array indexes) to the loop variable one at a time. Indexes
that do not exist will not be iterated:
for(var index in sparseArray) {
var value = sparseArray[index];
// Now do something with index and value
}
As noted in §6.5, a 
for/in
loop can return the names of inherited properties, such as
the names of methods that have been added to 
Array.prototype
. For this reason you
should not use a 
for/in
loop on an array unless you include an additional test to filter
out unwanted properties. You might use either of these tests:
for(var i in a) {
if (!a.hasOwnProperty(i)) continue;  // Skip inherited properties
// loop body here
}
for(var i in a) {
// Skip i if it is not a non-negative integer
if (String(Math.floor(Math.abs(Number(i)))) !== i) continue;
}
The ECMAScript specification allows the 
for/in
loop to iterate the properties of an
object in any order. Implementations typically iterate array elements in ascending or-
der, but this is not guaranteed. In particular, if an array has both object properties and
array elements, the property names may be returned in the order they were created,
7.6  Iterating Arrays | 147
Core JavaScript
rather than in numeric order. Implementations differ in how they handle this case, so
if iteration order matters for your algorithm, it is best to use a regular 
for
loop instead
of 
for/in
.
ECMAScript 5 defines a number of new methods for iterating array elements by passing
each one, in index order, to a function that you define. The 
forEach()
method is the
most general of these methods:
var data = [1,2,3,4,5];     // This is the array we want to iterate
var sumOfSquares = 0;       // We want to compute the sum of the squares of data
data.forEach(function(x) {  // Pass each element of data to this function
sumOfSquares += x*x;  // add up the squares
});
sumOfSquares                // =>55 : 1+4+9+16+25
forEach()
and related iteration methods enable a simple and powerful functional pro-
gramming style for working with arrays. They are covered in §7.9, and we’ll return to
them in §8.8, when we cover functional programming.
7.7  Multidimensional Arrays
JavaScript does not support true multidimensional arrays, but you can approximate
them with arrays of arrays. To access a value in an array of arrays, simply use the 
[]
operator twice. For example, suppose the variable 
matrix
is an array of arrays of num-
bers. Every element in 
matrix[x]
is an array of numbers. To access a particular number
within this array, you would write 
matrix[x][y]
. Here is a concrete example that uses
a two-dimensional array as a multiplication table:
// Create a multidimensional array
var table = new Array(10);               // 10 rows of the table
for(var i = 0; i < table.length; i++)
table[i] = new Array(10);            // Each row has 10 columns
// Initialize the array
for(var row = 0; row < table.length; row++) {
for(col = 0; col < table[row].length; col++) {
table[row][col] = row*col;
}
}
// Use the multidimensional array to compute 5*7
var product = table[5][7];  // 35
7.8  Array Methods
ECMAScript 3  defines  a number of useful  array  manipulation functions on
Array.prototype
, which means that they are available as methods of any array. These
ECMAScript 3 methods are introduced in the subsections below. As usual, complete
details can be found under 
Array
in the client-side reference section. ECMAScript 5
adds new array iteration methods; those methods are covered in §7.9.
148 | Chapter 7: Arrays
7.8.1  join()
The 
Array.join()
method converts all the elements of an array to strings and concat-
enates them, returning the resulting string. You can specify an optional string that
separates the elements in the resulting string. If no separator string is specified, a comma
is used. For example, the following lines of code produce the string “1,2,3”:
var a = [1, 2, 3];     // Create a new array with these three elements
a.join();              // => "1,2,3"
a.join(" ");           // => "1 2 3"
a.join("");            // => "123"
var b = new Array(10); // An array of length 10 with no elements
b.join('-')            // => '---------': a string of 9 hyphens
The 
Array.join()
method is the inverse of the 
String.split()
method, which creates
an array by breaking a string into pieces.
7.8.2  reverse()
The 
Array.reverse()
method reverses the order of the elements of an array and returns
the reversed array. It does this in place; in other words, it doesn’t create a new array
with the elements rearranged but instead rearranges them in the already existing array.
For example, the following code, which uses the 
reverse()
and 
join()
methods, pro-
duces the string “3,2,1”:
var a = [1,2,3];
a.reverse().join()  // => "3,2,1" and a is now [3,2,1]
7.8.3  sort()
Array.sort()
sorts the elements of an array in place and returns the sorted array. When
sort()
is called with no arguments, it sorts the array elements in alphabetical order
(temporarily converting them to strings to perform the comparison, if necessary):
var a = new Array("banana", "cherry", "apple");
a.sort();
var s = a.join(", ");  // s == "apple, banana, cherry"
If an array contains undefined elements, they are sorted to the end of the array.
To sort an array into some order other than alphabetical, you must pass a comparison
function as an argument to 
sort()
. This function decides which of its two arguments
should appear first in the sorted array. If the first argument should appear before the
second, the comparison function should return a number less than zero. If the first
argument should appear after the second in the sorted array, the function should return
a number greater than zero. And if the two values are equivalent (i.e., if their order is
irrelevant), the comparison function should return 0. So, for example, to sort array
elements into numerical rather than alphabetical order, you might do this:
var a = [33, 4, 1111, 222];
a.sort();                 // Alphabetical order:  1111, 222, 33, 4
a.sort(function(a,b) {    // Numerical order: 4, 33, 222, 1111
7.8  Array Methods | 149
Core JavaScript
return a-b;    // Returns &lt; 0, 0, or &gt; 0, depending on order
});
a.sort(function(a,b) {return b-a});   // Reverse numerical order
Note the convenient use of unnamed function expressions in this code. Since the com-
parison functions are used only once, there is no need to give them names.
As another example of sorting array items, you might perform a case-insensitive al-
phabetical sort on an array of strings by passing a comparison function that converts
both of its arguments to lowercase (with the 
toLowerCase()
method) before comparing
them:
a = ['ant', 'Bug', 'cat', 'Dog']
a.sort();                // case-sensitive sort: ['Bug','Dog','ant',cat']
a.sort(function(s,t) {   // Case-insensitive sort
var a = s.toLowerCase();
var b = t.toLowerCase();
if (a < b) return -1;
if (a > b) return 1;
return 0;
});               // => ['ant','Bug','cat','Dog']
7.8.4  concat()
The 
Array.concat()
method creates and returns a new array that contains the elements
of the original array on which 
concat()
was invoked, followed by each of the arguments
to 
concat()
. If any of these arguments is itself an array, then it is the array elements that
are concatenated, not the array itself. Note, however, that 
concat()
does not recursively
flatten arrays of arrays. 
concat()
does not modify the array on which it is invoked. Here
are some examples:
var a = [1,2,3];
a.concat(4, 5)          // Returns [1,2,3,4,5]
a.concat([4,5]);        // Returns [1,2,3,4,5]
a.concat([4,5],[6,7])   // Returns [1,2,3,4,5,6,7]
a.concat(4, [5,[6,7]])  // Returns [1,2,3,4,5,[6,7]]
7.8.5  slice()
The 
Array.slice()
method returns a slice, or subarray, of the specified array. Its two
arguments specify the start and end of the slice to be returned. The returned array
contains the element specified by the first argument and all subsequent elements up
to, but not including, the element specified by the second argument. If only one argu-
ment is specified, the returned array contains all elements from the start position to the
end of the array. If either argument is negative, it specifies an array element relative to
the last element in the array. An argument of -1, for example, specifies the last element
in the array, and an argument of -3 specifies the third from last element of the array.
Note that 
slice()
does not modify the array on which it is invoked. Here are some
examples:
var a = [1,2,3,4,5];
a.slice(0,3);    // Returns [1,2,3]
150 | Chapter 7: Arrays
a.slice(3);      // Returns [4,5]
a.slice(1,-1);   // Returns [2,3,4]
a.slice(-3,-2);  // Returns [3]
7.8.6  splice()
The 
Array.splice()
method is a general-purpose method for inserting or removing
elements from an array. Unlike 
slice()
and 
concat()
splice()
modifies the array on
which it is invoked. Note that 
splice()
and 
slice()
have very similar names but per-
form substantially different operations.
splice()
can delete elements from an array, insert new elements into an array, or per-
form both operations at the same time. Elements of the array that come after the in-
sertion or deletion point have their indexes increased or decreased as necessary so that
they remain contiguous with the rest of the array. The first argument to 
splice()
speci-
fies the array position at which the insertion and/or deletion is to begin. The second
argument specifies the number of elements that should be deleted from (spliced out of)
the array. If this second argument is omitted, all array elements from the start element
to the end of the array are removed. 
splice()
returns an array of the deleted elements,
or an empty array if no elements were deleted. For example:
var a = [1,2,3,4,5,6,7,8];
a.splice(4);    // Returns [5,6,7,8]; a is [1,2,3,4]
a.splice(1,2);  // Returns [2,3]; a is [1,4]
a.splice(1,1);  // Returns [4]; a is [1]
The first two arguments to 
splice()
specify which array elements are to be deleted.
These arguments may be followed by any number of additional arguments that specify
elements to be inserted into the array, starting at the position specified by the first
argument. For example:
var a = [1,2,3,4,5];
a.splice(2,0,'a','b');  // Returns []; a is [1,2,'a','b',3,4,5]
a.splice(2,2,[1,2],3);  // Returns ['a','b']; a is [1,2,[1,2],3,3,4,5]
Note that, unlike 
concat()
splice()
inserts arrays themselves, not the elements of those
arrays.
7.8.7  push() and pop()
The 
push()
and 
pop()
methods allow you to work with arrays as if they were stacks.
The 
push()
method appends one or more new elements to the end of an array and
returns the new length of the array. The 
pop()
method does the reverse: it deletes the
last element of an array, decrements the array length, and returns the value that it
removed. Note that both methods modify the array in place rather than produce a
modified copy of the array. The combination of 
push()
and 
pop()
allows you to use a
JavaScript array to implement a first-in, last-out stack. For example:
var stack = [];       // stack: []
stack.push(1,2);      // stack: [1,2]      Returns 2
stack.pop();          // stack: [1]        Returns 2
7.8  Array Methods | 151
Core JavaScript
stack.push(3);        // stack: [1,3]      Returns 2
stack.pop();          // stack: [1]        Returns 3
stack.push([4,5]);    // stack: [1,[4,5]]  Returns 2
stack.pop()           // stack: [1]        Returns [4,5]
stack.pop();          // stack: []         Returns 1
7.8.8  unshift() and shift()
The 
unshift()
and 
shift()
methods behave much like 
push()
and 
pop()
, except that
they insert and remove elements from the beginning of an array rather than from the
end. 
unshift()
adds an element or elements to the beginning of the array, shifts the
existing array elements up to higher indexes to make room, and returns the new length
of the array. 
shift()
removes and returns the first element of the array, shifting all
subsequent elements down one place to occupy the newly vacant space at the start of
the array. For example:
var a = [];            // a:[]
a.unshift(1);          // a:[1]         Returns: 1
a.unshift(22);         // a:[22,1]      Returns: 2
a.shift();             // a:[1]         Returns: 22
a.unshift(3,[4,5]);    // a:[3,[4,5],1] Returns: 3
a.shift();             // a:[[4,5],1]   Returns: 3
a.shift();             // a:[1]         Returns: [4,5]
a.shift();             // a:[]          Returns: 1
Note the possibly surprising behavior of 
unshift()
when it’s invoked with multiple
arguments. Instead of being inserted into the array one at a time, arguments are inserted
all at once (as with the 
splice()
method). This means that they appear in the resulting
array in the same order in which they appeared in the argument list. Had the elements
been inserted one at a time, their order would have been reversed.
7.8.9  toString() and toLocaleString()
An array, like any JavaScript object, has a 
toString()
method. For an array, this method
converts each of its elements to a string (calling the 
toString()
methods of its elements,
if necessary) and outputs a comma-separated list of those strings. Note that the output
does not include square brackets or any other sort of delimiter around the array value.
For example:
[1,2,3].toString()          // Yields '1,2,3'
["a", "b", "c"].toString()  // Yields 'a,b,c'
[1, [2,'c']].toString()     // Yields '1,2,c'
Note that the 
join()
method returns the same string when it is invoked with no
arguments.
toLocaleString()
is the localized version of 
toString()
. It converts each array element
to a string by calling the 
toLocaleString()
method of the element, and then it concat-
enates the resulting strings using a locale-specific (and implementation-defined) sepa-
rator string.
152 | Chapter 7: Arrays
Documents you may be interested
Documents you may be interested