open pdf and draw c# : Add hyperlink pdf file software Library dll windows .net wpf web forms %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D14-part1542

setter method defines any properties, it will do so on 
o
, and it will again leave the
prototype chain unmodified.
6.2.3  Property Access Errors
Property access expressions do not always return or set a value. This section explains
the things that can go wrong when you query or set a property.
It is not an error to query a property that does not exist. If the property 
x
is not found
as an own property or an inherited property of 
o
, the property access expression 
o.x
evaluates to 
undefined
. Recall that our book object has a “sub-title” property, but not
a “subtitle” property:
book.subtitle;    // => undefined: property doesn't exist
It is an error, however, to attempt to query a property of an object that does not exist.
The 
null
and 
undefined
values have no properties, and it is an error to query properties
of these values. Continuing the above example:
// Raises a TypeError exception. undefined doesn't have a length property
var len = book.subtitle.length;
Unless you are certain that both 
book
and 
book.subtitle
are (or behave like) objects,
you shouldn’t write the expression 
book.subtitle.length
, since it might raise an ex-
ception. Here are two ways to guard against this kind of exception:
// A verbose and explicit technique
var len = undefined;
if (book) {
if (book.subtitle) len = book.subtitle.length;
}
// A concise and idiomatic alternative to get subtitle length or undefined
var len = book && book.subtitle && book.subtitle.length;
To understand why this idiomatic expression works to prevent TypeError exceptions,
you might want to review the short-circuiting behavior of the 
&&
operator in §4.10.1.
Attempting to set a property on 
null
or 
undefined
also causes a TypeError, of course.
Attempts to set properties on other values do not always succeed, either: some prop-
erties are read-only and cannot be set, and some objects do not allow the addition of
new properties. Curiously, however, these failed attempts to set properties usually fail
silently:
// The prototype properties of built-in constructors are read-only.
Object.prototype = 0;  // Assignment fails silently; Object.prototype unchanged
This historical quirk of JavaScript is rectified in the strict mode of ECMAScript 5. In
strict mode, any failed attempt to set a property throws a TypeError exception.
6.2  Querying and Setting Properties | 123
Core JavaScript
Add hyperlink 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
change link in pdf file; pdf hyperlinks
Add hyperlink 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
add links to pdf; add links to pdf acrobat
The rules that specify when a property assignment succeeds and when it fails are in-
tuitive but difficult to express concisely. An attempt to set a property 
p
of an object 
o
fails in these circumstances:
o
has an own property 
p
that is read-only: it is not possible to set read-only prop-
erties. (See the 
defineProperty()
method, however, for an exception that allows
configurable read-only properties to be set.)
o
has an inherited property 
p
that is read-only: it is not possible to hide an inherited
read-only property with an own property of the same name.
o
does not have an own property 
p
o
does not inherit a property 
p
with a setter
method, and 
o
’s 
extensible
attribute (see §6.8.3) is 
false
. If 
p
does not already
exist on 
o
, and if there is no setter method to call, then 
p
must be added to 
o
. But
if 
o
is not extensible, then no new properties can be defined on it.
6.3  Deleting Properties
The 
delete
operator (§4.13.3) removes a property from an object. Its single operand
should be a property access expression. Surprisingly, 
delete
does not operate on the
value of the property but on the property itself:
delete book.author;          // The book object now has no author property.
delete book["main title"];   // Now it doesn't have "main title", either.
The 
delete
operator only deletes own properties, not inherited ones. (To delete an
inherited property, you must delete it from the prototype object in which it is defined.
Doing this affects every object that inherits from that prototype.)
delete
expression evaluates to 
true
if the delete succeeded or if the delete had no
effect (such as deleting a nonexistent property). 
delete
also evaluates to 
true
when used
(meaninglessly) with an expression that is not a property access expression:
o = {x:1};          // o has own property x and inherits property toString
delete o.x;         // Delete x, and return true
delete o.x;         // Do nothing (x doesn't exist), and return true
delete o.toString;  // Do nothing (toString isn't an own property), return true
delete 1;           // Nonsense, but evaluates to true
delete
does not remove properties that have a configurable attribute of 
false
. (Though
it will remove configurable properties of nonextensible objects.) Certain properties of
built-in objects are nonconfigurable, as are properties of the global object created by
variable declaration and function declaration. In strict mode, attempting to delete a
nonconfigurable  property  causes  a  TypeError.  In  non-strict  mode  (and  in
ECMAScript 3), 
delete
simply evaluates to 
false
in this case:
delete Object.prototype;  // Can't delete; property is non-configurable
var x = 1;                // Declare a global variable
delete this.x;            // Can't delete this property
function f() {}           // Declare a global function
delete this.f;            // Can't delete this property either
124 | Chapter 6: Objects
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. can edit PDF password and digital signature, and set PDF file permission Hyperlink Edit.
add links to pdf in acrobat; check links in pdf
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. edit PDF password and digital signature, and set PDF file permission Hyperlink Edit.
add hyperlink to pdf in; pdf hyperlink
When deleting configurable properties of the global object in non-strict mode, you can
omit the reference to the global object and simply follow the 
delete
operator with the
property name:
this.x = 1;      // Create a configurable global property (no var)
delete x;        // And delete it
In strict mode, however, 
delete
raises a SyntaxError if its operand is an unqualified
identifier like 
x
, and you have to be explicit about the property access:
delete x;        // SyntaxError in strict mode
delete this.x;   // This works
6.4  Testing Properties
JavaScript objects can be thought of as sets of properties, and it is often useful to be
able to test for membership in the set—to check whether an object has a property with
a given name. You can do this with the 
in
operator, with the 
hasOwnProperty()
and
propertyIsEnumerable()
methods, or simply by querying the property.
The 
in
operator expects a property name (as a string) on its left side and an object on
its right. It returns 
true
if the object has an own property or an inherited property by
that name:
var o = { x: 1 }
"x" in o;         // true: o has an own property "x"
"y" in o;         // false: o doesn't have a property "y"
"toString" in o;  // true: o inherits a toString property
The 
hasOwnProperty()
method of an object tests whether that object has an own prop-
erty with the given name. It returns 
false
for inherited properties:
var o = { x: 1 }
o.hasOwnProperty("x");        // true: o has an own property x
o.hasOwnProperty("y");        // false: o doesn't have a property y
o.hasOwnProperty("toString"); // false: toString is an inherited property
The 
propertyIsEnumerable()
refines the 
hasOwnProperty()
test. It returns 
true
only if
the named property is an own property and its 
enumerable
attribute is 
true
. Certain
built-in properties are not enumerable. Properties created by normal JavaScript code
are enumerable unless you’ve used one of the ECMAScript 5 methods shown later to
make them nonenumerable.
var o = inherit({ y: 2 });
o.x = 1;
o.propertyIsEnumerable("x");  // true: o has an own enumerable property x
o.propertyIsEnumerable("y");  // false: y is inherited, not own
Object.prototype.propertyIsEnumerable("toString"); // false: not enumerable
Instead of using the 
in
operator it is often sufficient to simply query the property and
use 
!==
to make sure it is not undefined:
var o = { x: 1 }
o.x !== undefined;        // true: o has a property x
6.4  Testing Properties | 125
Core JavaScript
C# PDF Library SDK to view, edit, convert, process PDF file for C#
offers robust APIs for editing PDF document hyperlink (url) and SDK for .NET allows you to read, add, edit, update, and delete PDF file metadata, like
add a link to a pdf; adding hyperlinks to a pdf
VB.NET PDF Library SDK to view, edit, convert, process PDF file
RasterEdge PDF SDK for .NET package offers robust APIs for editing PDF document hyperlink (url), which provide quick access to the website or other file.
add links to pdf document; add email link to pdf
o.y !== undefined;        // false: o doesn't have a property y
o.toString !== undefined; // true: o inherits a toString property
There is one thing the 
in
operator can do that the simple property access technique
shown above cannot do. 
in
can distinguish between properties that do not exist and
properties that exist but have been set to 
undefined
. Consider this code:
var o = { x: undefined }   // Property is explicitly set to undefined
o.x !== undefined          // false: property exists but is undefined
o.y !== undefined          // false: property doesn't even exist
"x" in o                   // true: the property exists
"y" in o                   // false: the property doesn't exists
delete o.x;                // Delete the property x
"x" in o                   // false: it doesn't exist anymore
Note that the code above uses the 
!==
operator instead of 
!=
!==
and 
===
distinguish
between 
undefined
and 
null
. Sometimes, however, you don’t want to make this
distinction:
// If o has a property x whose value is not null or undefined, double it.
if (o.x != null) o.x *= 2;
// If o has a property x whose value does not convert to false, double it.
// If x is undefined, null, false, "", 0, or NaN, leave it alone.
if (o.x) o.x *= 2;
6.5  Enumerating Properties
Instead of testing for the existence of individual properties, we sometimes want to
iterate through or obtain a list of all the properties of an object. This is usually done
with the 
for/in
loop, although ECMAScript 5 provides two handy alternatives.
The 
for/in
loop was covered in §5.5.4. It runs the body of the loop once for each
enumerable property (own or inherited) of the specified object, assigning the name of
the property to the loop variable. Built-in methods that objects inherit are not
enumerable, but the properties that your code adds to objects are enumerable (unless
you use one of the functions described later to make them nonenumerable). For
example:
var o = {x:1, y:2, z:3};             // Three enumerable own properties
o.propertyIsEnumerable("toString")   // => false: not enumerable
for(p in o)                          // Loop through the properties
console.log(p);                  // Prints x, y, and z, but not toString
Some utility libraries add new methods (or other properties) to 
Object.prototype
so
that they are inherited by, and available to, all objects. Prior to ECMAScript 5, however,
there is no way to make these added methods nonenumerable, so they are enumerated
by 
for/in
loops. To guard against this, you might want to filter the properties returned
by 
for/in
. Here are two ways you might do so:
for(p in o) {
if (!o.hasOwnProperty(p)) continue;       // Skip inherited properties
}
126 | Chapter 6: Objects
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.
add hyperlinks to pdf; pdf links
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Change Word hyperlink to PDF hyperlink and bookmark. Add necessary references: The target resolution of the output tiff file, it is invalid for pdf file.
add links to pdf file; clickable links in pdf from word
for(p in o) {
if (typeof o[p] === "function") continue; // Skip methods
}
Example 6-2 defines utility functions that use 
for/in
loops to manipulate object prop-
erties in helpful ways. The 
extend()
function, in particular, is one that is commonly
included in JavaScript utility libraries.
2
Example 6-2. Object utility functions that enumerate properties
/*
* Copy the enumerable properties of p to o, and return o.
* If o and p have a property by the same name, o's property is overwritten.
* This function does not handle getters and setters or copy attributes.
*/
function extend(o, p) {
for(prop in p) {                         // For all props in p.
o[prop] = p[prop];                   // Add the property to o.
}
return o;
}
/*
* Copy the enumerable properties of p to o, and return o.
* If o and p have a property by the same name, o's property is left alone.
* This function does not handle getters and setters or copy attributes.
*/
function merge(o, p) {
for(prop in p) {                           // For all props in p.
if (o.hasOwnProperty[prop]) continue;  // Except those already in o.
o[prop] = p[prop];                     // Add the property to o.
}
return o;
}
/*
* Remove properties from o if there is not a property with the same name in p.
* Return o.
*/
function restrict(o, p) {
for(prop in o) {                         // For all props in o
if (!(prop in p)) delete o[prop];    // Delete if not in p
}
return o;
}
/*
* For each property of p, delete the property with the same name from o.
* Return o.
*/
function subtract(o, p) {
2.The implementation of 
extend()
shown here is correct but does not compensate for a well-known bug in
Internet Explorer. We’ll see a more robust version of 
extend()
in Example 8-3.
6.5  Enumerating Properties | 127
Core JavaScript
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 hyperlink to pdf; add hyperlink pdf file
.NET PDF SDK - Description of All PDF Processing Control Feastures
Create signatures in existing PDF signature fields; Create signatures in new fields which hold the signature; Add signature image to PDF file. PDF Hyperlink Edit
accessible links in pdf; clickable links in pdf files
for(prop in p) {                         // For all props in p
delete o[prop];                      // Delete from o (deleting a
// nonexistent prop is harmless)
}
return o;
}
/*
* Return a new object that holds the properties of both o and p.
* If o and p have properties by the same name, the values from o are used.
*/
function union(o,p) { return extend(extend({},o), p); }
/*
* Return a new object that holds only the properties of o that also appear
* in p. This is something like the intersection of o and p, but the values of
* the properties in p are discarded
*/
function intersection(o,p) { return restrict(extend({}, o), p); }
/*
* Return an array that holds the names of the enumerable own properties of o.
*/
function keys(o) {
if (typeof o !== "object") throw TypeError();  // Object argument required
var result = [];                 // The array we will return
for(var prop in o) {             // For all enumerable properties
if (o.hasOwnProperty(prop))  // If it is an own property
result.push(prop);       // add it to the array.
}
return result;                   // Return the array.
}
In addition to the 
for/in
loop, ECMAScript 5 defines two functions that enumerate
property names. The first is 
Object.keys()
, which returns an array of the names of the
enumerable own properties of an object. It works just like the 
keys()
utility function
shown in Example 6-2.
The second ECMAScript 5 property enumeration function is 
Object.getOwnProperty
Names()
. It works like 
Object.keys()
but returns the names of all the own properties of
the specified object, not just the enumerable properties. There is no way to write this
function in ECMAScript 3, because ECMAScript 3 does not provide a way to obtain
the nonenumerable properties of an object.
6.6  Property Getters and Setters
We’ve said that an object property is a name, a value, and a set of attributes. In
ECMAScript 5
3
the value may be replaced by one or two methods, known as a getter
3.And in recent ECMAScript 3 versions of major browsers other than IE.
128 | Chapter 6: Objects
and a setter. Properties defined by getters and setters are sometimes known as accessor
properties to distinguish them from data properties that have a simple value.
When a program queries the value of an accessor property, JavaScript invokes the getter
method (passing no arguments). The return value of this method becomes the value of
the property access expression. When a program sets the value of an accessor property,
JavaScript invokes the setter method, passing the value of the right-hand side of the
assignment. This method is responsible for “setting,” in some sense, the property value.
The return value of the setter method is ignored.
Accessor properties do not have a writable attribute as data properties do. If a property
has both a getter and a setter method, it is a read/write property. If it has only a getter
method, it is a read-only property. And if it has only a setter method, it is a write-only
property (something that is not possible with data properties) and attempts to read it
always evaluate to 
undefined
.
The easiest way to define accessor properties is with an extension to the object literal
syntax:
var o = {
// An ordinary data property 
data_prop: value,
// An accessor property defined as a pair of functions
get accessor_prop() { /* function body here */ },
set accessor_prop(value) { /* function body here */ }
};
Accessor properties are defined as one or two functions whose name is the same as the
property name, and with the 
function
keyword replaced with 
get
and/or 
set
. Note that
no colon is used to separate the name of the property from the functions that access
that property, but that a comma is still required after the function body to separate the
method from the next method or data property. As an example, consider the following
object that represents a 2D Cartesian point. It has ordinary data properties to represent
the X and Y coordinates of the point, and it has accessor properties for the equivalent
polar coordinates of the point:
var p = {
// x and y are regular read-write data properties.
x: 1.0,
y: 1.0,
// r is a read-write accessor property with getter and setter.
// Don't forget to put a comma after accessor methods.
get r() { return Math.sqrt(this.x*this.x + this.y*this.y); },
set r(newvalue) {
var oldvalue = Math.sqrt(this.x*this.x + this.y*this.y);
var ratio = newvalue/oldvalue;
this.x *= ratio;
this.y *= ratio;
},
6.6  Property Getters and Setters | 129
Core JavaScript
// theta is a read-only accessor property with getter only.
get theta() { return Math.atan2(this.y, this.x); }
};
Note the use of the keyword 
this
in the getters and setter above. JavaScript invokes
these functions as methods of the object on which they are defined, which means that
within the body of the function 
this
refers to the point object. So the getter method for
the 
r
property can refer to the 
x
and 
y
properties as 
this.x
and 
this.y
. Methods and
the 
this
keyword are covered in more detail in §8.2.2.
Accessor properties are inherited, just as data properties are, so you can use the object
p
defined above as a prototype for other points. You can give the new objects their own
x
and 
y
properties, and they’ll inherit the 
r
and 
theta
properties:
var q = inherit(p);  // Create a new object that inherits getters and setters
q.x = 0, q.y = 0;    // Create q's own data properties
console.log(q.r);    // And use the inherited accessor properties
console.log(q.theta);
The code above uses accessor properties to define an API that provides two represen-
tations (Cartesian coordinates and polar coordinates) of a single set of data. Other
reasons to use accessor properties include sanity checking of property writes and re-
turning different values on each property read:
// This object generates strictly increasing serial numbers
var serialnum = {
// This data property holds the next serial number.
// The $ in the property name hints that it is a private property.
$n: 0,
// Return the current value and increment it
get next() { return this.$n++; },
// Set a new value of n, but only if it is larger than current
set next(n) {
if (n >= this.$n) this.$n = n;
else throw "serial number can only be set to a larger value";
}
};
Finally, here is one more example that uses a getter method to implement a property
with “magical” behavior.
// This object has accessor properties that return random numbers.
// The expression "random.octet", for example, yields a random number
// between 0 and 255 each time it is evaluated.
var random = {
get octet() { return Math.floor(Math.random()*256); },
get uint16() { return Math.floor(Math.random()*65536); },
get int16() { return Math.floor(Math.random()*65536)-32768; }
};
This section has shown only how to define accessor properties when creating a new
object from an object literal. The next section shows how to add accessor properties
to existing objects.
130 | Chapter 6: Objects
6.7  Property Attributes
In addition to a name and value, properties have attributes that specify whether they
can be written, enumerated, and configured. In ECMAScript 3, there is no way to set
these attributes: all properties created by ECMAScript 3 programs are writable, enu-
merable, and configurable, and there is no way to change this. This section explains
the ECMAScript 5 API for querying and setting property attributes. This API is partic-
ularly important to library authors because:
• It allows them to add methods to prototype objects and make them nonenumer-
able, like built-in methods.
• It allows them to “lock down” their objects, defining properties that cannot be
changed or deleted.
For the purposes of this section, we are going to consider getter and setter methods of
an accessor property to be property attributes. Following this logic, we’ll even say that
the value of a data property is an attribute as well. Thus, we can say that a property has
a name and four attributes. The four attributes of a data property are value, writable,
enumerable, and configurable. Accessor properties don’t have a value attribute or a
writable attribute: their writability is determined by the presence or absence of a setter.
So the four attributes of an accessor property are get, set, enumerable, and configurable.
The ECMAScript 5 methods for querying and setting the attributes of a property use
an object called a property descriptor to represent the set of four attributes. A property
descriptor object has properties with the same names as the attributes of the property
it describes. Thus, the property descriptor object of a data property has properties
named 
value
writable
enumerable
, and 
configurable
. And the descriptor for an ac-
cessor property has 
get
and 
set
properties instead of 
value
and 
writable
. The 
writa
ble
enumerable
, and 
configurable
properties are boolean values, and the 
get
and 
set
properties are function values, of course.
To obtain the property descriptor for a named property of a specified object, call
Object.getOwnPropertyDescriptor()
:
// Returns {value: 1, writable:true, enumerable:true, configurable:true}
Object.getOwnPropertyDescriptor({x:1}, "x");
// Now query the octet property of the random object defined above.
// Returns { get: /*func*/, set:undefined, enumerable:true, configurable:true}
Object.getOwnPropertyDescriptor(random, "octet");
// Returns undefined for inherited properties and properties that don't exist.
Object.getOwnPropertyDescriptor({}, "x");         // undefined, no such prop
Object.getOwnPropertyDescriptor({}, "toString");  // undefined, inherited
As its name implies, 
Object.getOwnPropertyDescriptor()
works only for own proper-
ties. To query the attributes of inherited properties, you must explicitly traverse the
prototype chain (see 
Object.getPrototypeOf()
in §6.8.1).
6.7  Property Attributes | 131
Core JavaScript
To set the attributes of a property, or to create a new property with the specified at-
tributes, call 
Object.defineProperty()
, passing the object to be modified, the name of
the property to be created or altered, and the property descriptor object:
var o = {};  // Start with no properties at all
// Add a nonenumerable data property x with value 1.
Object.defineProperty(o, "x", { value : 1, 
writable: true,
enumerable: false,
configurable: true});
// Check that the property is there but is nonenumerable
o.x;           // => 1
Object.keys(o) // => []
// Now modify the property x so that it is read-only
Object.defineProperty(o, "x", { writable: false });
// Try to change the value of the property
o.x = 2;      // Fails silently or throws TypeError in strict mode
o.x           // => 1
// The property is still configurable, so we can change its value like this:
Object.defineProperty(o, "x", { value: 2 });
o.x           // => 2
// Now change x from a data property to an accessor property
Object.defineProperty(o, "x", { get: function() { return 0; } });
o.x           // => 0
The property descriptor you pass to 
Object.defineProperty()
does not have to include
all four attributes. If you’re creating a new property, then omitted attributes are taken
to be 
false
or 
undefined
. If you’re modifying an existing property, then the attributes
you omit are simply left unchanged. Note that this method alters an existing own
property or creates a new own property, but it will not alter an inherited property.
If you want to create or modify more than one property at a time, use 
Object.define
Properties()
. The first argument is the object that is to be modified. The second ar-
gument is an object that maps the names of the properties to be created or modified to
the property descriptors for those properties. For example:
var p = Object.defineProperties({}, {
x: { value: 1, writable: true, enumerable:true, configurable:true },  
y: { value: 1, writable: true, enumerable:true, configurable:true },
r: { 
get: function() { return Math.sqrt(this.x*this.x + this.y*this.y) },
enumerable:true,
configurable:true
}
});
This code starts with an empty object, then adds two data properties and one read-only
accessor property to it. It relies on the fact that 
Object.defineProperties()
returns the
modified object (as does 
Object.defineProperty()
).
132 | Chapter 6: Objects
Documents you may be interested
Documents you may be interested