pdf annotation in c# : Adding hyperlinks to pdf documents software application cloud windows html winforms class %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D80-part1615

Number
The 
Number()
constructor.
Object
The 
Object()
constructor.
RangeError
The 
RangeError()
constructor.
ReferenceError
The 
ReferenceError()
constructor.
RegExp
The 
RegExp()
constructor.
String
The 
String()
constructor.
SyntaxError
The 
SyntaxError()
constructor.
TypeError
The 
TypeError()
constructor.
URIError
The 
URIError()
constructor.
Description
The global object is a predefined object that serves as a placeholder for the global properties
and functions of JavaScript. All other predefined objects, functions, and properties are ac-
cessible through the global object. The global object is not a property of any other object, so
it does not have a name. (The title of this reference page was chosen simply for organizational
convenience and does not indicate that the global object is named “Global”). In top-level
JavaScript code, you can refer to the global object with the keyword 
this
. It is rarely necessary
to refer to the global object in this way, however, because the global object serves as the top
of the scope chain, which means that unqualified variable and function names are looked up
as properties of the object. When JavaScript code refers to the 
parseInt()
function, for ex-
ample, it is referring to the 
parseInt
property of the global object. The fact that the global
object is the top of the scope chain also means that all variables declared in top-level JavaScript
code become properties of the global object.
The global object is simply an object, not a class. There is no 
Global()
constructor, and there
is no way to instantiate a new global object.
When JavaScript is embedded in a particular environment, the global object is usually given
additional properties that are specific to that environment. In fact, the type of the global object
is not specified by the ECMAScript standard, and an implementation or embedding of Java-
Script may use an object of any type as the global object, as long as the object defines the basic
properties and functions listed here. In client-side JavaScript, for example, the global object
is a Window object and represents the web browser window within which the JavaScript code
is running.
Global
Core JavaScript Reference | 783
Core JavaScript
Reference
Adding hyperlinks to pdf documents - 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
convert a word document to pdf with hyperlinks; convert doc to pdf with hyperlinks
Adding hyperlinks to pdf documents - 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
pdf link to attached file; change link in pdf
Example
In core JavaScript, none of the predefined properties of the global object are enumerable, so
you can list all implicitly and explicitly declared global variables with a 
for/in
loop like this:
var variables = ""
for(var name in this)
variables += name + "\n";
See Also
Window
in Part IV ; Chapter 3
Infinity
a numeric property that represents infinity
Synopsis
Infinity
Description
Infinity
is a global property that contains the special numeric value representing positive
infinity. The 
Infinity
property is not enumerated by 
for/in
loops and cannot be deleted with
the 
delete
operator. Note that 
Infinity
is not a constant and can be set to any other value,
something that you should take care not to do. (
Number.POSITIVE_INFINITY
is a constant,
however.)
See Also
isFinite()
NaN
Number.POSITIVE_INFINITY
isFinite()
determine whether a number is finite
Synopsis
isFinite(n)
Arguments
n
The number to be tested.
Returns
true
if 
n
is (or can be converted to) a finite number, or 
false
if 
n
is 
NaN
(not a number) or
positive or negative infinity.
See Also
Infinity
isNaN()
NaN
Number.NaN
Number.NEGATIVE_INFINITY
Number.POSITIVE_INFINITY
Infinity
784 | Core JavaScript Reference
isNaN()
check for not-a-number
Synopsis
isNaN(x)
Arguments
x
The value to be tested.
Returns
true
if 
x
is not a number or if it is the special numeric value NaN. It returns 
false
if x is any
other number.
Description
“NaN” is an acronym for “not-a-number”. The global variable 
NaN
holds a special numeric
value (also known as 
NaN
) that represents an illegal number (such as the result of zero divided
by zero). 
isNaN()
tests whether its argument is not a number. This function returns 
false
if
x
is, or can be converted to, a number other than 
NaN
. It returns 
true
if 
x
is not and cannot be
converted to a number, or if it is equal to 
NaN
.
NaN
has the special property that it is not equal to any value including itself. So if you want to
test specifically for the 
NaN
value, rather than generically for any non-number, do not write 
x
=== NaN
: that will always be 
false
. Instead use the expression 
x !== x
: this will evaluate to
true
only if 
x
is 
NaN
.
A common use of 
isNaN()
is to test the results of 
parseFloat()
and 
parseInt()
to determine
if they represent legal numbers.
Example
isNaN(0);                  // => false
isNaN(0/0);                // => true
isNaN(parseInt("3"));      // => false
isNaN(parseInt("hello"));  // => true
isNaN("3");                // => false
isNaN("hello");            // => true
isNaN(true);               // => false
isNaN(undefined);          // => true
See Also
isFinite()
NaN
Number.NaN
parseFloat()
parseInt()
isNaN()
Core JavaScript Reference | 785
Core JavaScript
Reference
JSON
ECMAScript 5
JSON parsing and stringification
Description
JSON
is a simple object that serves as the namespace for the global ECMAScript 5 functions
JSON.parse()
and 
JSON.stringify()
JSON
is not a constructor. Prior to ECMAScript 5, com-
patible JSON parsing and serialization functions are available from http://json.org/json2.js.
“JSON” stands for JavaScript Object Notation. JSON is a data serialization format based on
JavaScript literals, and can represent the 
null
value, the boolean values 
true
and 
false
, float-
ing-point numbers (using JavaScript numeric literals), strings (using JavaScript string literals),
arrays of values (using JavaScript array literal syntax) and string to value mappings (using
JavaScript object literal syntax). The primitive value 
undefined
as well as the numbers NaN
and Infinity are not representable in JSON. JavaScript functions, Dates, RegExps and Errors
are not supported either.
Example
// Make a deep copy of any object or array that can be JSON-serialized
function deepcopy(o) { return JSON.parse(JSON.stringify(o)); }
See Also
JSON.parse()
JSON.stringify()
§6.9http://json.org
JSON.parse()
ECMAScript 5
parse a JSON-formatted string
Synopsis
JSON.parse(s)
JSON.parse(s, reviver)
Arguments
s
The string to be parsed
reviver
An optional function that can transform parsed values.
Returns
An object, array, or primitive value parsed from 
s
(and optionally modified by 
reviver
).
Description
JSON.parse()
is a global function for parsing JSON-formatted strings. Typically, you pass a
single string argument and 
JSON.parse()
returns the JavaScript value that the string represents.
JSON
786 | Core JavaScript Reference
You can use the optional 
reviver
argument to filter or post-process the parsed value before
it is returned. If it is specified, the 
reviver
function is invoked once for each primitive value
(but not the objects or arrays that contain those primitive values) parsed from 
s
reviver
is
invoked with two arguments. The first is a property name—either an object property name
or an array index converted to a string. The second argument is the primitive value of that
object property or array element. 
reviver
is invoked as a method of the object or array that
contains the primitive value. As a special case, if the string 
s
represents a primitive value rather
than the more typical object or array, then that primitive value will be stored in a newly-created
object using a property whose name is the empty string. In this case, 
reviver
will be invoked
once on that newly created object, with an empty string as its first argument and the primitive
value as its second.
The return value of the 
reviver
function becomes the new value of the named property. If
reviver
returns its second argument, then the property will remain unchanged. If reviver
returns 
undefined
(or returns no value at all) then the named property will be deleted from
the object or array before 
JSON.parse()
returns to the user.
Example
Many uses of 
JSON.parse()
are trivial:
var data = JSON.parse(text);
The 
JSON.stringify()
function converts Date objects to strings, and you can use a 
reviver
function to reverse this transformation. The example below also filters property names and
returns 
undefined
to remove certain properties from the result object:
var data JSON.parse(text, function(name, value) {
// Remove any values whose property name begins with an underscore
if (name[0] == '_') return undefined;
// If the value is a string in ISO 8601 date format convert it to a Date.
if (typeof value === "string" &&
/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\d\d\dZ$/.test(value))
return new Date(value);
// Otherwise, return the value unchanged
return value
});
See Also
JSON.stringify()
§6.9
JSON.stringify()
ECMAScript 5
serialize an object, array or primitive value
Synopsis
JSON.stringify(o)
JSON.stringify(o, filter)
JSON.stringify(o, filter, indent)
JSON.stringify()
Core JavaScript Reference | 787
Core JavaScript
Reference
Arguments
o
The object, array, or primitive value to be converted to a JSON string.
filter
An optional function that can replace values before stringification, or an array that con-
tains the names of properties to be stringified.
indent
An optional argument that specifies an indentation string or the number of spaces to use
for indentation when formatted human-readable output is desired. If omitted, the re-
turned string contains no extraneous spaces and is machine-readable, but not easily
human-readable.
Returns
A JSON-formatted string representing the value 
o
, as filtered by 
filter
and formatted ac-
cording to 
indent
.
Description
JSON.stringify()
converts a primitive value, object or array to a JSON-formatted string that
can later be parsed with 
JSON.parse()
. Usually, this function is called with a single argument
and returns the corresponding string.
When 
JSON.stringify()
is called with a single argument, and when that value consists only
of objects, arrays, strings, numbers, booleans and the 
null
value the stringification is com-
pletely straightforward. When the value to be stringified contains objects that are instances
of a class, however, the stringification process is more complex. If 
JSON.stringify()
encoun-
ters any object (or array) with a method named 
toJSON()
, it invokes that method on the object
and stringifies the return value instead of the object itself. It invokes 
toJSON()
with a single
string argument which is the property name or array index of the object. The Date class defines
toJSON()
method that converts Dates to strings using the 
Date.toISOString()
method. No
other built-in JavaScript class defines a 
toJSON()
method, but you can define them for your
own classes. Remember that, despite its name, 
toJSON()
does not have to stringify the object
on which it is invoked: it merely has to return a value that will be stringified in place of the
original object.
The second argument to 
JSON.stringify()
allows a second layer of filtering for the stringifi-
cation process. This optional argument may be a function or an array and the two cases
provide completely different filtering functionality. If you pass a function, it is a replacer
function, and works something like the 
toJSON()
method described above. If specified, the
replacer function is invoked for each value to be stringified. The 
this
value is the object or
array within which the value is defined. The first argument to the replacer function is the
object property name or array index of the value within that object, and the second argument
is the value itself. That value is replaced by the return value of the replacer function. If the
replacer returns 
undefined
or returns nothing at all, then that value (and its array element or
object property) are omitted from the stringification.
If an array of strings (or numbers—they are converted to strings) is passed instead as the
second argument, these are used as the names of object properties. Any property whose name
JSON.stringify()
788 | Core JavaScript Reference
is not in the array will be omitted from stringification. Furthermore, the returned string will
include properties in the same order that they appear in the array.
JSON.stringify()
normally returns a machine-readable string without any whitespace or
newlines inserted. If you want the output to be more human readable, specify a third argu-
ment. If you specify a number between 1 and 10, 
JSON.stringify()
will insert newlines and
use the specified number of spaces to indent each “level” of output. If you specify a non-empty
string instead, 
JSON.stringify()
will insert newlines and use that string (or the first 10 char-
acters of it) to indent each level.
Examples
// Basic serialization
var text = JSON.stringify(data);
// Specify exactly what fields to serialize
var text = JSON.stringify(address, ["city","state","country"]);
// Specify a replacer function so that RegExp objects can be serialized
var text = JSON.stringify(patterns, function(key, value) {
if (value.constructor === RegExp) return value.toString();
return value;
});
// Or acheive the same replacement like this:
RegExp.prototype.toJSON = function() { return this.toString(); }
See Also
JSON.parse()
§6.9
Math
mathematical functions and constants
Synopsis
Math.constant
Math.function()
Constants
Math.E
The constant e, the base of the natural logarithm.
Math.LN10
The natural logarithm of 10.
Math.LN2
The natural logarithm of 2.
Math.LOG10E
The base-10 logarithm of e.
Math
Core JavaScript Reference | 789
Core JavaScript
Reference
Download from Wow! eBook <www.wowebook.com>
Math.LOG2E
The base-2 logarithm of e.
Math.PI
The constant π.
Math.SQRT1_2
The number 1 divided by the square root of 2.
Math.SQRT2
The square root of 2.
Static Functions
Math.abs()
Computes an absolute value.
Math.acos()
Computes an arccosine.
Math.asin()
Computes an arcsine.
Math.atan()
Computes an arctangent.
Math.atan2()
Computes the angle from the X axis to a point.
Math.ceil()
Rounds a number up.
Math.cos()
Computes a cosine.
Math.exp()
Computes a power of e.
Math.floor()
Rounds a number down.
Math.log()
Computes a natural logarithm.
Math.max()
Returns the larger of two numbers.
Math.min()
Returns the smaller of two numbers.
Math.pow()
Computes x  y
Math.random()
Computes a random number.
Math
790 | Core JavaScript Reference
Math.round()
Rounds to the nearest integer.
Math.sin()
Computes a sine.
Math.sqrt()
Computes a square root.
Math.tan()
Computes a tangent.
Description
Math is an object that defines properties that refer to useful mathematical functions and
constants. These functions and constants are invoked with syntax like this:
y = Math.sin(x);
area = radius * radius * Math.PI;
Math is not a class of objects as Date and String are. There is no 
Math()
constructor, and
functions like 
Math.sin()
are simply functions, not methods that operate on an object.
See Also
Number
Math.abs()
compute an absolute value
Synopsis
Math.abs(x)
Arguments
x
Any number.
Returns
The absolute value of 
x
.
Math.acos()
compute an arccosine
Synopsis
Math.acos(x)
Math.acos()
Core JavaScript Reference | 791
Core JavaScript
Reference
Arguments
x
A number between −1.0 and 1.0.
Returns
The arccosine, or inverse cosine, of the specified value 
x
. This return value is between 0 and
π radians.
Math.asin()
compute an arcsine
Synopsis
Math.asin(x)
Arguments
x
A number between −1.0 and 1.0.
Returns
The arcsine of the specified value 
x
. This return value is between -π/2 and π/2 radians.
Math.atan()
compute an arctangent
Synopsis
Math.atan(x)
Arguments
x
Any number.
Returns
The arc tangent of the specified value 
x
. This return value is between -π/2 and π/2 radians.
Math.atan2()
compute the angle from the X axis to a point
Synopsis
Math.atan2(y, x)
Math.asin()
792 | Core JavaScript Reference
Documents you may be interested
Documents you may be interested