open pdf and draw c# : Add hyperlink in pdf software SDK cloud windows wpf .net class %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D15-part1543

We saw the ECMAScript 5 method 
Object.create()
in §6.1. We learned there that the
first argument to that method is the prototype object for the newly created object. This
method also accepts a second optional argument, which is the same as the second
argument to 
Object.defineProperties()
. If you pass a set of property descriptors to
Object.create()
, then they are used to add properties to the newly created object.
Object.defineProperty()
and 
Object.defineProperties()
throw TypeError if the at-
tempt to create or modify a property is not allowed. This happens if you attempt to
add a new property to a nonextensible (see §6.8.3) object. The other reasons that these
methods might throw TypeError have to do with the attributes themselves. The writ-
able attribute governs attempts to change the value attribute. And the configurable
attribute governs attempts to change the other attributes (and also specifies whether a
property can be deleted). The rules are not completely straightforward, however. It is
possible to change the value of a nonwritable property if that property is configurable,
for example. Also, it is possible to change a property from writable to nonwritable even
if  that  property  is  nonconfigurable.  Here  are  the  complete  rules.  Calls  to
Object.defineProperty()
or 
Object.defineProperties()
that attempt to violate them
throw TypeError:
• If an object is not extensible, you can edit its existing own properties, but you
cannot add new properties to it.
• If a property is not configurable, you cannot change its configurable or enumerable
attributes.
• If an accessor property is not configurable, you cannot change its getter or setter
method, and you cannot change it to a data property.
• If a data property is not configurable, you cannot change it to an accessor property.
• If a data property is not configurable, you cannot change its writable attribute from
false
to 
true
, but you can change it from 
true
to 
false
.
• If a data property is not configurable and not writable, you cannot change its value.
You can change the value of a property that is configurable but nonwritable, how-
ever (because that would be the same as making it writable, then changing the
value, then converting it back to nonwritable).
Example 6-2 included an 
extend()
function that copied properties from one object to
another. That function simply copied the name and value of the properties and ignored
their attributes. Furthermore, it did not copy the getter and setter methods of accessor
properties, but simply converted them into static data properties. Example 6-3 shows
 new  version  of 
extend()
that  uses 
Object.getOwnPropertyDescriptor()
and
Object.defineProperty()
to copy all property attributes. Rather than being written as
a function, this version is defined as a new Object method and is added as a nonenu-
merable property to 
Object.prototype
.
6.7  Property Attributes | 133
Core JavaScript
Add hyperlink in 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; add a link to a pdf in acrobat
Add hyperlink in 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 url link to pdf; adding hyperlinks to pdf documents
Example 6-3. Copying property attributes
/*
* Add a nonenumerable extend() method to Object.prototype.
* This method extends the object on which it is called by copying properties
* from the object passed as its argument.  All property attributes are
* copied, not just the property value.  All own properties (even non-
* enumerable ones) of the argument object are copied unless a property
* with the same name already exists in the target object.
*/
Object.defineProperty(Object.prototype,
"extend",                  // Define Object.prototype.extend
{
writable: true,
enumerable: false,     // Make it nonenumerable
configurable: true,
value: function(o) {   // Its value is this function
// Get all own props, even nonenumerable ones
var names = Object.getOwnPropertyNames(o);
// Loop through them
for(var i = 0; i < names.length; i++) {
// Skip props already in this object
if (names[i] in this) continue;
// Get property description from o
var desc = Object.getOwnPropertyDescriptor(o,names[i]);
// Use it to create property on this
Object.defineProperty(this, names[i], desc);
}
}
});
6.7.1  Legacy API for Getters and Setters
The object literal syntax for accessor properties described in §6.6 allows us to define
accessor properties in new objects, but it doesn’t allow us to query the getter and setter
methods or to add new accessor properties to existing objects. In ECMAScript 5 we
can use 
Object.getOwnPropertyDescriptor()
and 
Object.defineProperty()
to do these
things.
Most JavaScript implementations (with the major exception of the IE web browser)
supported the object literal 
get
and 
set
syntax even before the adoption of
ECMAScript 5. These implementations support a nonstandard legacy API for querying
and setting getters and setters. This API consists of four methods available on all objects.
__lookupGetter__()
and 
__lookupSetter__()
return the getter or setter method for a
named property. And 
__defineGetter__()
and 
__defineSetter__()
define a getter or
setter: pass the property name first and the getter or setter method second. The names
of each of these methods begin and end with double underscores to indicate that they
are nonstandard methods. These nonstandard methods are not documented in the
reference section.
134 | Chapter 6: Objects
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Change Word hyperlink to PDF hyperlink and bookmark. VB.NET Demo Code for Converting Word to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
add links to pdf document; c# read pdf from url
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Change Excel hyperlink to PDF hyperlink and bookmark. VB.NET Demo Code for Converting Excel to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
adding hyperlinks to pdf files; clickable links in pdf files
6.8  Object Attributes
Every object has associated prototype, class, and extensible attributes. The subsections
that follow explain what these attributes do and (where possible) how to query and
set them.
6.8.1  The prototype Attribute
An object’s prototype attribute specifies the object from which it inherits properties.
(Review §6.1.3 and §6.2.2 for more on prototypes and property inheritance.) This is
such an important attribute that we’ll usually simply say “the prototype of 
o
” rather
than “the prototype attribute of 
o
.” Also, it is important to understand that when
prototype
appears in code font, it refers to an ordinary object property, not to the
prototype attribute.
The prototype attribute is set when an object is created. Recall from §6.1.3 that objects
created from object literals use 
Object.prototype
as their prototype. Objects created
with 
new
use the value of the 
prototype
property of their constructor function as their
prototype. And objects created with 
Object.create()
use the first argument to that
function (which may be 
null
) as their prototype.
In ECMAScript 5, you can query the prototype of any object by passing that object to
Object.getPrototypeOf()
. There is no equivalent function in ECMAScript 3, but it is
often possible to determine the prototype of an object 
o
using the expression
o.constructor.prototype
. Objects created with a 
new
expression usually inherit a
constructor
property that refers to the constructor function used to create the object.
And, as described above, constructor functions have a 
prototype
property that specifies
the prototype for objects created using that constructor. This is explained in more detail
in §9.2, which also explains why it is not a completely reliable method for determining
an  object’s  prototype.  Note  that  objects  created  by  object  literals  or  by
Object.create()
have a 
constructor
property that refers to the 
Object()
constructor.
Thus, 
constructor.prototype
refers to the correct prototype for object literals, but does
not usually do so for objects created with 
Object.create()
.
To determine whether one object is the prototype of (or is part of the prototype chain
of) another object, use the 
isPrototypeOf()
method. To find out if 
p
is the prototype
of 
o
write 
p.isPrototypeOf(o)
. For example:
var p = {x:1};                    // Define a prototype object.
var o = Object.create(p);         // Create an object with that prototype.
p.isPrototypeOf(o)                // => true: o inherits from p
Object.prototype.isPrototypeOf(o) // => true: p inherits from Object.prototype
Note that 
isPrototypeOf()
performs a function similar to the 
instanceof
operator (see
§4.9.4).
Mozilla’s implementation of JavaScript has (since the early days of Netscape) exposed
the prototype attribute through the specially named 
__proto__
property, and you can
use this property to directly query or set the prototype of any object. Using 
__proto__
6.8  Object Attributes | 135
Core JavaScript
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. Hyperlink Edit. XDoc.PDF for .NET allows C# developers to edit hyperlink of PDF document
add links to pdf in acrobat; chrome pdf from link
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. Hyperlink Edit. XDoc.PDF for .NET allows VB.NET developers to edit hyperlink of PDF
add url pdf; add page number to pdf hyperlink
is not portable: it has not been (and probably never will be) implemented by IE or
Opera, although it is currently supported by Safari and Chrome. Versions of Firefox
that implement ECMAScript 5 still support 
__proto__
, but restrict its ability to change
the prototype of nonextensible objects.
6.8.2  The class Attribute
An object’s class attribute is a string that provides information about the type of the
object. Neither ECMAScript 3 nor ECMAScript 5 provide any way to set this attribute,
and there is only an indirect technique for querying it. The default 
toString()
method
(inherited from 
Object.prototype
) returns a string of the form:
[object class]
So to obtain the class of an object, you can invoke this 
toString()
method on it, and
extract the eighth through the second-to-last characters of the returned string. The
tricky part is that many objects inherit other, more useful 
toString()
methods, and to
invoke the correct version of 
toString()
, we must do so indirectly, using the
Function.call()
method (see §8.7.3). Example 6-4 defines a function that returns the
class of any object you pass it.
Example 6-4. A classof() function
function classof(o) {
if (o === null) return "Null";
if (o === undefined) return "Undefined";
return Object.prototype.toString.call(o).slice(8,-1);
}
This 
classof()
function works for any JavaScript value. Numbers, strings, and booleans
behave like objects when the 
toString()
method is invoked on them, and the function
includes special cases for 
null
and 
undefined
. (The special cases are not required in
ECMAScript 5.) Objects created through built-in constructors such as 
Array
and 
Date
have class attributes that match the names of their constructors. Host objects typically
have meaningful class attributes as well, though this is implementation-dependent.
Objects created through object literals or by 
Object.create
have a class attribute of
“Object”. If you define your own constructor function, any objects you create with it
will have a class attribute of “Object”: there is no way to specify the class attribute for
your own classes of objects:
classof(null)       // => "Null"
classof(1)          // => "Number"
classof("")         // => "String"
classof(false)      // => "Boolean"
classof({})         // => "Object"
classof([])         // => "Array"
classof(/./)        // => "Regexp"
classof(new Date()) // => "Date"
classof(window)     // => "Window" (a client-side host object)
function f() {};    // Define a custom constructor
classof(new f());   // => "Object"
136 | Chapter 6: Objects
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Change Word hyperlink to PDF hyperlink and bookmark. C#.NET Sample Code: Convert Word to PDF in C#.NET Project. Add necessary references:
add hyperlink to pdf online; add a link to a pdf
.NET PDF Document Viewing, Annotation, Conversion & Processing
Extract hyperlink inside PDF. PDF Write. Insert text, text box into PDF. Edit, delete text from PDF. Insert images into PDF. Edit, remove images from PDF. Add,
adding hyperlinks to a pdf; add link to pdf file
6.8.3  The extensible Attribute
The extensible attribute of an object specifies whether new properties can be added to
the object or not. In ECMAScript 3, all built-in and user-defined objects are implicitly
extensible, and the extensibility of host objects is implementation defined. In ECMA-
Script 5, all built-in and user-defined objects are extensible unless they have been
converted to be nonextensible, and the extensibility of host objects is again implemen-
tation defined.
ECMAScript 5 defines functions for querying and setting the extensibility of an object.
To determine whether an object is extensible, pass it to 
Object.isExtensible()
. To
make an object nonextensible, pass it to 
Object.preventExtensions()
. Note that there
is no way to make an object extensible again once you have made it nonextensible. Also
note that calling 
preventExtensions()
only affects the extensibility of the object itself.
If new properties are added to the prototype of a nonextensible object, the nonexten-
sible object will inherit those new properties.
The purpose of the extensible attribute is to be able to “lock down” objects into a known
state and prevent outside tampering. The extensible object attribute is often used in
conjunction  with  the  configurable  and  writable  property  attributes,  and
ECMAScript 5 defines functions that make it easy to set these attributes together.
Object.seal()
works like 
Object.preventExtensions()
, but in addition to making the
object nonextensible, it also makes all of the own properties of that object nonconfig-
urable. This means that new properties cannot be added to the object, and existing
properties cannot be deleted or configured. Existing properties that are writable can
still be set, however. There is no way to unseal a sealed object. You can use
Object.isSealed()
to determine whether an object is sealed.
Object.freeze()
locks objects down even more tightly. In addition to making the object
nonextensible and its properties nonconfigurable, it also makes all of the object’s own
data properties read-only. (If the object has accessor properties with setter methods,
these are not affected and can still be invoked by assignment to the property.) Use
Object.isFrozen()
to determine if an object is frozen.
It is important to understand that 
Object.seal()
and 
Object.freeze()
affect only the
object they are passed: they have no effect on the prototype of that object. If you want
to thoroughly lock down an object, you probably need to seal or freeze the objects in
the prototype chain as well.
Object.preventExtensions()
Object.seal()
, and 
Object.freeze()
all return the object
that they are passed, which means that you can use them in nested function invocations:
// Create a sealed object with a frozen prototype and a nonenumerable property
var o = Object.seal(Object.create(Object.freeze({x:1}),
{y: {value: 2, writable: true}}));
6.8  Object Attributes | 137
Core JavaScript
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
Export PowerPoint hyperlink to PDF. VB.NET Demo Code for Converting PowerPoint to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
add url to pdf; add hyperlink in pdf
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
Export PowerPoint hyperlink to PDF in .NET console application. C#.NET Demo Code: Convert PowerPoint to PDF in C#.NET Application. Add necessary references:
pdf reader link; add links to pdf
6.9  Serializing Objects
Object serialization is the process of converting an object’s state to a string from which
it can later be restored. ECMAScript 5 provides native functions 
JSON.stringify()
and
JSON.parse()
to serialize and restore JavaScript objects. These functions use the JSON
data interchange format. JSON stands for “JavaScript Object Notation,” and its syntax
is very similar to that of JavaScript object and array literals:
o = {x:1, y:{z:[false,null,""]}}; // Define a test object
s = JSON.stringify(o);            // s is '{"x":1,"y":{"z":[false,null,""]}}'
p = JSON.parse(s);                // p is a deep copy of o
The native implementation of these functions in ECMAScript 5 was modeled very
closely after the public-domain ECMAScript 3 implementation available at http://json
.org/json2.js. For practical purposes, the implementations are the same, and you can
use these ECMAScript 5 functions in ECMAScript 3 with this json2.js module.
JSON syntax is a subset of JavaScript syntax, and it cannot represent all JavaScript
values. Objects, arrays, strings, finite numbers, 
true
false
, and 
null
are supported and
can be serialized and restored. 
NaN
Infinity
, and 
-Infinity
are serialized to 
null
. Date
objects are serialized to ISO-formatted date strings (see the 
Date.toJSON()
function),
but 
JSON.parse()
leaves these in string form and does not restore the original Date
object. Function, RegExp, and Error objects and the 
undefined
value cannot be serial-
ized or restored. 
JSON.stringify()
serializes only the enumerable own properties of an
object. If a property value cannot be serialized, that property is simply omitted from
the stringified output. Both 
JSON.stringify()
and 
JSON.parse()
accept optional second
arguments that can be used to customize the serialization and/or restoration process
by specifying a list of properties to be serialized, for example, or by converting certain
values during the serialization or stringification process. Complete documentation for
these functions is in the reference section.
6.10  Object Methods
As discussed earlier, all JavaScript objects (except those explicitly created without a
prototype) inherit properties from 
Object.prototype
. These inherited properties are
primarily methods, and because they are universally available, they are of particular
interest to JavaScript programmers. We’ve already seen the 
hasOwnProperty()
,
propertyIsEnumerable()
, and 
isPrototypeOf()
methods. (And we’ve also already cov-
ered quite a few static functions defined on the 
Object
constructor, such as
Object.create()
and 
Object.getPrototypeOf()
.) This section explains a handful of uni-
versal object methods that are defined on 
Object.prototype
, but which are intended to
be overridden by other, more specialized classes.
138 | Chapter 6: Objects
6.10.1  The toString() Method
The 
toString()
method takes no arguments; it returns a string that somehow represents
the value of the object on which it is invoked. JavaScript invokes this method of an
object whenever it needs to convert the object to a string. This occurs, for example,
when you use the 
+
operator to concatenate a string with an object or when you pass
an object to a method that expects a string.
The default 
toString()
method is not very informative (though it is useful for deter-
mining the class of an object, as we saw in §6.8.2). For example, the following line of
code simply evaluates to the string “[object Object]”:
var s = { x:1, y:1 }.toString();
Because this default method does not display much useful information, many classes
define their own versions of 
toString()
. For example, when an array is converted to a
string, you obtain a list of the array elements, themselves each converted to a string,
and when a function is converted to a string, you obtain the source code for the function.
These customized versions of the 
toString()
method are documented in the reference
section.  See 
Array.toString()
Date.toString()
 and 
Function.toString()
 for
example.
§9.6.3 describes how to define a custom 
toString()
method for your own classes.
6.10.2  The toLocaleString() Method
In addition to the basic 
toString()
method, objects all have a 
toLocaleString()
. The
purpose of this method is to return a localized string representation of the object. The
default 
toLocaleString()
method defined by Object doesn’t do any localization itself:
it simply calls 
toString()
and returns that value. The Date and Number classes define
customized versions of 
toLocaleString()
that attempt to format numbers, dates, and
times according to local conventions. Array defines a 
toLocaleString()
method that
works like 
toString()
except that it formats array elements by calling their 
toLocale
String()
methods instead of their 
toString()
methods.
6.10.3  The toJSON() Method
Object.prototype
does  not  actually  define  a 
toJSON()
method,  but  the
JSON.stringify()
method (see §6.9) looks for a 
toJSON()
method on any object it is
asked to serialize. If this method exists on the object to be serialized, it is invoked, and
the return value is serialized, instead of the original object. See 
Date.toJSON()
for an
example.
6.10  Object Methods | 139
Core JavaScript
6.10.4  The valueOf() Method
The 
valueOf()
method is much like the 
toString()
method, but it is called when Java-
Script needs to convert an object to some primitive type other than a string—typically,
a number. JavaScript calls this method automatically if an object is used in a context
where a primitive value is required. The default 
valueOf()
method does nothing inter-
esting, but some of the built-in classes define their own 
valueOf()
method (see
Date.valueOf()
, for example). §9.6.3 explains how to define a 
valueOf()
method for
custom object types you define.
140 | Chapter 6: Objects
Download from Wow! eBook <www.wowebook.com>
CHAPTER 7
Arrays
An array is an ordered collection of values. Each value is called an element, and each
element has a numeric position in the array, known as its index. JavaScript arrays are
untyped: an array element may be of any type, and different elements of the same array
may be of different types. Array elements may even be objects or other arrays, which
allows you to create complex data structures, such as arrays of objects and arrays of
arrays. JavaScript arrays are zero-based and use 32-bit indexes: the index of the first
element is 0, and the highest possible index is 4294967294 (2
32
−2), for a maximum
array size of 4,294,967,295 elements. JavaScript arrays are dynamic: they grow or shrink
as needed and there is no need to declare a fixed size for the array when you create it
or to reallocate it when the size changes. JavaScript arrays may be sparse: the elements
need not have contiguous indexes and there may be gaps. Every JavaScript array has a
length
property. For nonsparse arrays, this property specifies the number of elements
in the array. For sparse arrays, 
length
is larger than the index of all elements.
JavaScript arrays are a specialized form of JavaScript object, and array indexes are really
little more than property names that happen to be integers. We’ll talk more about the
specializations of arrays elsewhere in this chapter. Implementations typically optimize
arrays so that access to numerically indexed array elements is generally significantly
faster than access to regular object properties.
Arrays inherit properties from 
Array.prototype
, which defines a rich set of array ma-
nipulation methods, covered in §7.8 and §7.9. Most of these methods are generic,
which means that they work correctly not only for true arrays, but for any “array-like
object.” We’ll discuss array-like objects in §7.11. In ECMAScript 5, strings behave like
arrays of characters, and we’ll discuss this in §7.12.
7.1  Creating Arrays
The easiest way to create an array is with an array literal, which is simply a comma-
separated list of array elements within square brackets. For example:
141
var empty = [];                 // An array with no elements
var primes = [2, 3, 5, 7, 11];  // An array with 5 numeric elements
var misc = [ 1.1, true, "a", ]; // 3 elements of various types + trailing comma
The values in an array literal need not be constants; they may be arbitrary expressions:
var base = 1024;
var table = [base, base+1, base+2, base+3];
Array literals can contain object literals or other array literals:
var b = [[1,{x:1, y:2}], [2, {x:3, y:4}]];
If you omit a value from an array literal, the omitted element is given the value
undefined
:
var count = [1,,3]; // An array with 3 elements, the middle one undefined.
var undefs = [,,];  // An array with 2 elements, both undefined.
Array literal syntax allows an optional trailing comma, so 
[,,]
has only two elements,
not three.
Another way to create an array is with the 
Array()
constructor. You can invoke this
constructor in three distinct ways:
• Call it with no arguments:
var a = new Array();
This method creates an empty array with no elements and is equivalent to the array
literal 
[]
.
• Call it with a single numeric argument, which specifies a length:
var a = new Array(10);
This technique creates an array with the specified length. This form of the
Array()
constructor can be used to preallocate an array when you know in advance
how many elements will be required. Note that no values are stored in the array,
and the array index properties “0”, “1”, and so on are not even defined for the array.
• Explicitly specify two or more array elements or a single non-numeric element for
the array:
var a = new Array(5, 4, 3, 2, 1, "testing, testing");
In this form, the constructor arguments become the elements of the new array.
Using an array literal is almost always simpler than this usage of the 
Array()
constructor.
7.2  Reading and Writing Array Elements
You access an element of an array using the 
[]
operator. A reference to the array should
appear to the left of the brackets. An arbitrary expression that has a non-negative integer
142 | Chapter 7: Arrays
Documents you may be interested
Documents you may be interested