open pdf and draw c# : Add hyperlink pdf file Library control component .net azure html mvc %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D28-part1557

behavior allows you to call 
exec()
repeatedly in order to loop through all the regular
expression matches in a string. For example:
var pattern = /Java/g;
var text = "JavaScript is more fun than Java!";
var result;
while((result = pattern.exec(text)) != null) {
alert("Matched '" + result[0] + "'" +
" at position " + result.index +
"; next search begins at " + pattern.lastIndex);
}
The other RegExp method is 
test()
test()
is a much simpler method than 
exec()
. It
takes a string and returns 
true
if the string contains a match for the regular expression:
var pattern = /java/i;
pattern.test("JavaScript");  // Returns true
Calling 
test()
is equivalent to calling 
exec()
and returning 
true
if the return value of
exec()
is not 
null
. Because of this equivalence, the 
test()
method behaves the same
way as the 
exec()
method when invoked for a global regular expression: it begins
searching the specified string at the position specified by 
lastIndex
, and if it finds a
match, it sets 
lastIndex
to the position of the character immediately following the
match. Thus, you can loop through a string using the 
test()
method just as you can
with the 
exec()
method.
The String methods 
search()
replace()
, and 
match()
do not use the 
lastIndex
property
as 
exec()
and 
test()
do. In fact, the String methods simply reset 
lastIndex
to 0. If you
use 
exec()
or 
test()
on a pattern that has the 
g
flag set, and you are searching multiple
strings, you must either find all the matches in each string so that 
lastIndex
is auto-
matically reset to zero (this happens when the last search fails), or you must explicitly
set the 
lastIndex
property to 0 yourself. If you forget to do this, you may start searching
a new string at some arbitrary position within the string rather than from the beginning.
If your RegExp doesn’t have the 
g
flag set, then you don’t have to worry about any of
this, of course. Keep in mind also that in ECMAScript 5 each evaluation of a regular
expression literal creates a new RegExp object with its own 
lastIndex
property, and
this reduces the risk of accidentally using a “leftover” 
lastIndex
value.
10.3  The RegExp Object | 263
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
add hyperlink to pdf acrobat; pdf email link
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
pdf link open in new window; clickable links in pdf
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.
adding an email link to a pdf; add links to pdf file
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 hyperlinks to pdf online; add link to pdf
CHAPTER 11
JavaScript Subsets and Extensions
Until now, this book has described the complete and official JavaScript language, as
standardized by ECMAScript 3 and ECMAScript 5. This chapter instead describes
subsets and supersets of JavaScript. The subsets have been defined, for the most part,
for security purposes: a script written using only a secure language subset can be exe-
cuted safely even if it comes from an untrusted source such as an ad server. §11.1
describes a few of these subsets.
The ECMAScript 3 standard was published in 1999 and a decade elapsed before the
standard was updated to ECMAScript 5 in 2009. Brendan Eich, the creator of Java-
Script, continued to evolve the language during that decade (the ECMAScript specifi-
cation explicitly allows language extensions) and, with the Mozilla project, released
JavaScript versions 1.5, 1.6, 1.7, 1.8, and 1.8.1 in Firefox 1.0, 1.5, 2, 3, and 3.5. Some
of the features of these extensions to JavaScript have been codified in ECMAScript 5,
but many remain nonstandard. Future versions of ECMAScript are expected to stand-
ardize at least some of the remaining nonstandard features.
The Firefox browser supports these extensions, as does the Spidermonkey JavaScript
interpreter that Firefox is based on. Mozilla’s Java-based JavaScript interpreter, Rhino,
(see §12.1) also supports most of the extensions. Because these language extensions
are nonstandard, however, they will not be useful to web developers who require lan-
guage compatibility across all browsers. They are documented in this chapter because:
• they are quite powerful;
• they may become standard in the future;
• they can be used to write Firefox extensions;
• they can be used in server-side JavaScript programming, when the underlying
JavaScript engine is Spidermonkey or Rhino (see §12.1).
After a preliminary section on language subsets, the rest of this chapter describes these
language extensions. Because they are nonstandard, they are documented in tutorial
style with less rigor than the language features described elsewhere in the book.
265
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 hyperlink to pdf; add links to 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 in preview; add email link to pdf
11.1  JavaScript Subsets
Most language subsets are defined to allow the secure execution of untrusted code.
There is one interesting subset defined for different reasons. We’ll cover that one first,
and then cover secure language subsets.
11.1.1  The Good Parts
Douglas Crockford’s short book JavaScript: The Good Parts (O’Reilly) describes a
JavaScript subset that consists of the parts of the language that he thinks are worth
using. The goal of this subset is to simplify the language, hide quirks and imperfections,
and ultimately, make programming easier and programs better. Crockford explains his
motivation:
Most programming languages contain good parts and bad parts. I discovered that I could
be a better programmer by using only the good parts and avoiding the bad parts.
Crockford’s subset does not include the 
with
and 
continue
statements or the 
eval()
function. It defines functions using function definition expressions only and does not
include the function definition statement. The subset requires the bodies of loops and
conditionals to be enclosed in curly braces: it does not allow the braces to be omitted
if the body consists of a single statement. It requires any statement that does not end
with a curly brace to be terminated with a semicolon.
The subset does not include the comma operator, the bitwise operators, or the 
++
and
--
operators. It also disallows 
==
and 
!=
because of the type conversion they perform,
requiring use of 
===
and 
!==
instead.
Since JavaScript does not have block scope, Crockford’s subset restricts the 
var
state-
ment to appear only at the top level of a function body and requires programmers to
declare all of a function’s variables using a single 
var
as the first statement in a function
body. The subset discourages the use of global variables, but this is a coding convention
rather than an actual language restriction.
Crockford’s online code-quality checking tool at http://jslint.com includes an option to
enforce conformance to The Good Parts. In addition to ensuring that your code uses
only the allowed features, the JSLint tool also enforces coding style rules, such as proper
indentation.
Crockford’s book was written before the strict mode of ECMAScript 5 was defined,
but many of the “bad parts” of JavaScript he seeks to discourage in his book are pro-
hibited by the use of strict mode. With the adoption of the ECMAScript 5 standard,
the JSLint tool now requires programs to include a “use strict” directive when “The
Good Parts” option is selected.
11.1.2  Subsets for Security
The Good Parts is a language subset designed for aesthetic reasons and with a desire
to improve programmer productivity. There is a larger class of subsets that have been
266 | Chapter 11: JavaScript Subsets and Extensions
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.
pdf hyperlinks; add hyperlink to pdf in
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.
change link in pdf file; add hyperlink pdf document
designed for the purpose of safely running untrusted JavaScript in a secure container
or “sandbox.” Secure subsets work by disallowing all language features and APIs that
can allow code to break out of its sandbox and affect the global execution environment.
Each subset is coupled with a static verifier that parses code to ensure that it conforms
to the subset. Since language subsets that can be statically verified tend to be quite
restrictive, some sandboxing systems define a larger, less restrictive subset and add a
code transformation step that verifies that code conforms to the larger subset, trans-
forms it to use a smaller language subset, and adds runtime checks where static analysis
of the code is not sufficient to ensure security.
In order to allow JavaScript to be statically verified to be safe, a number of features
must be removed:
eval()
and the 
Function()
constructor are not allowed in any secure subset because
they allow the execution of arbitrary strings of code, and these strings cannot be
statically analyzed.
• The 
this
keyword is forbidden or restricted because functions (in non-strict mode)
can access the global object through 
this
. Preventing access to the global object is
one of the key purposes of any sandboxing system.
• The 
with
statement is often forbidden in secure subsets because it makes static code
verification more difficult.
• Certain global variables are not allowed in secure subsets. In client-side JavaScript,
the browser window object does double-duty as the global object, so code is not
allowed to refer to the 
window
object. Similarly, the client-side 
document
object de-
fines methods that allow complete control over page content. This is too much
power to give to untrusted code. Secure subsets can take two different approaches
to global variables like 
document
. They can forbid them entirely, and instead define
a custom API that sandboxed code can use to access the limited portion of the web
page that has been alloted to it. Alternatively, the “container” in which the sand-
boxed code is run can define a facade or proxy 
document
object that implements
only the safe parts of the standard DOM API.
• Certain special properties and methods are forbidden in secure subsets because
they give too much power to the sandboxed code. These typically include the
caller
and 
callee
properties of the 
arguments
object (though some subsets do not
allow the 
arguments
object to be used at all), the 
call()
and 
apply()
methods of
functions, and the 
constructor
and 
prototype
properties. Nonstandard properties
such as 
__proto__
are also forbidden. Some subsets blacklist unsafe properties and
globals. Others whitelist a specific set of properties know to be safe.
• Static analysis is sufficient to prevent access to special properties when the property
access expression is written using the 
.
operator. But property access with 
[]
is
more difficult because arbitrary string expressions within the square brackets can-
not be statically analyzed. For this reason, secure subsets usually forbid the use of
square brackets unless the argument is a numeric or string literal. Secure subsets
replace the 
[]
operators with global functions for querying and setting object
11.1  JavaScript Subsets | 267
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.
convert a word document to pdf with hyperlinks; add a link to a pdf in acrobat
.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
pdf link to email; add links to pdf in acrobat
properties—these functions perform runtime checks to ensure that they aren’t used
to access forbidden properties.
Some of these restrictions, such as forbidding the use of 
eval()
and the 
with
statement,
are not much of a burden for programmers, since these features are not commonly used
in JavaScript programming. Others, such as the restriction on the use of square brackets
for property access are quite onerous, and this is where code translation comes in. A
translator can automatically transform the use of square brackets, for example, into a
function call that includes runtime checks. Similar transformations can allow the safe
use of the 
this
keyword. There is a tradeoff, of course, between the safety of these
runtime checks and execution speed of the sandboxed code.
A number of secure subsets have been implemented. Although a complete description
of any subset is beyond the scope of this book, we’ll briefly describe some of the most
important:
ADsafe
ADsafe (http://adsafe.org) was one of the first security subsets proposed. It was
created by Douglas Crockford (who also defined The Good Parts subset). ADsafe
relies on static verification only, and it uses JSLint (http://jslint.org) as its verifier.
It forbids access to most global variables and defines an 
ADSAFE
variable that pro-
vides access to a secure API, including special-purpose DOM methods. ADsafe is
not in wide use, but it was an influential proof-of-concept that influenced other
secure subsets.
dojox.secure
The dojox.secure subset (http://www.sitepen.com/blog/2008/08/01/secure-mashups
-with-dojoxsecure/) is an extension to the Dojo toolkit (http://dojotoolkit.org) that
was inspired by ADsafe. Like ADsafe, it is based on static verification of a restrictive
language subset. Unlike ADsafe, it allows use of the standard DOM API. Also, it
includes a verifier written in JavaScript, so that untrusted code can be dynamically
verified before being evaluated.
Caja
Caja (http://code.google.com/p/google-caja/) is Google’s open-source secure subset.
Caja (Spanish for “box”) defines two language subsets. Cajita (“little box”) is a
narrow subset like that used by ADsafe and dojox.secure. Valija (“suitcase” or
“baggage”) is a much broader language that is close to regular ECMAScript 5 strict
mode (with the removal of 
eval()
). Caja itself is the name of the compiler that
transforms (or “cajoles”) web content (HTML, CSS, and JavaScript code) into se-
cure modules that can be safely hosted on a web page without being able to affect
the page as a whole or other modules on the page.
Caja is part of the OpenSocial API (http://code.google.com/apis/opensocial/) and has
been adopted by Yahoo! for use on its websites. The content available at the portal
http://my.yahoo.com, for example, is organized into Caja modules.
268 | Chapter 11: JavaScript Subsets and Extensions
FBJS
FBJS is the variant of JavaScript used by Facebook (http://facebook.com) to allow
untrusted content on users’ profile pages. FBJS relies on code transformation to
ensure security. The transformer inserts runtime checks to prevent access to the
global object through the 
this
keyword. And it renames all top-level identifiers by
adding a module-specific prefix. Any attempt to set or query global variables or
variables belonging to another module is prevented because of this renaming. Fur-
thermore, any calls to 
eval()
are transformed by this identifier prefixing into calls
to a nonexistent function. FBJS emulates a safe subset of the DOM API.
Microsoft Web Sandbox
Microsoft’s Web Sandbox (http://websandbox.livelabs.com/) defines a broad subset
of JavaScript (plus HTML and CSS) and makes it secure through radical code re-
writing, effectively reimplementing a secure JavaScript virtual machine on top of
nonsecure JavaScript.
11.2  Constants and Scoped Variables
We now leave language subsets behind and transition to language extensions. In Java-
Script 1.5 and later, you can use the 
const
keyword to define constants. Constants are
like variables except that assignments to them are ignored (attempting to alter a con-
stant does not cause an error) and attempts to redeclare them cause errors:
const pi = 3.14;  // Define a constant and give it a value.
pi = 4;           // Any future assignments to it are silently ignored.
const pi = 4;     // It is an error to redeclare a constant.
var pi = 4;       // This is also an error.
The 
const
keyword behaves much like the 
var
keyword: there is no block scope, and
constants are hoisted to the top of the enclosing function definition. (See §3.10.1)
The lack of block scope for variables in JavaScript has long been considered a short-
coming of the language, and JavaScript 1.7 addresses it by adding the 
let
keyword to
the language. The keyword 
const
has always been a reserved (but unused) word in
JavaScript, so constants can be added without breaking any existing code. The 
let
keyword was not reserved, so it is not recognized unless you explicitly opt-in to version
1.7 or later.
JavaScript Versions
In this chapter, when we refer to a specific JavaScript version number, we’re referring
specifically to Mozilla’s version of the language, as implemented in the Spidermonkey
and Rhino interpreters and the Firefox web browser.
Some of the language extensions here define new keywords (such as 
let
) and to avoid
breaking existing code that uses that keyword, JavaScript requires you to explicitly
request the new version of the language in order to use the extension. If you are using
Spidermonkey or Rhino as a stand-alone interpreter, you can specify the desired
11.2  Constants and Scoped Variables | 269
Core JavaScript
language version with a command-line option or by calling the built-in 
version()
func-
tion. (It expects the version number times ten. Pass 170 to select JavaScript 1.7 and
enable the 
let
keyword.) In Firefox, you can opt in to language extensions using a script
tag like this:
<script type="application/javascript; version=1.8">
The 
let
keyword can be used in four ways:
• as a variable declaration like 
var
;
• in a 
for
or 
for/in
loop, as a substitute for 
var
;
• as a block statement, to define new variables and explicitly delimit their scope; and
• to define variables that are scoped to a single expression.
The simplest way to use 
let
is as a drop-in replacement for 
var
. Variables declared with
var
are defined throughout the enclosing function. Variables declared with 
let
are
defined only within the closest enclosing block (and any blocks nested within it, of
course). If you declare a variable with 
let
inside the body of a loop, for example, it does
not exist outside the loop:
function oddsums(n) {
let total = 0, result=[];        // Defined throughout the function
for(let x = 1; x <= n; x++) {    // x is only defined in the loop
let odd = 2*x-1;             // odd only defined in this loop
total += odd;
result.push(total);
}
// Using x or odd here would cause a ReferenceError
return result;
}
oddsums(5);  // Returns [1,4,9,16,25]
Notice that this code also uses 
let
as a replacement for 
var
in the 
for
loop. This creates
a variable whose scope is the body of the loop plus the condition and increment clauses
of the loop. You can also use 
let
in this way in 
for/in
(and 
for each
; see §11.4.1) loops:
o = {x:1,y:2};
for(let p in o) console.log(p);      // Prints x and y
for each(let v in o) console.log(v); // Prints 1 and 2
console.log(p)                       // ReferenceError: p is not defined
There is an interesting difference between 
let
used as a declaration statement and
let
used as a loop initializer. Used as a declaration, the variable initializer expressions
are evaluated in the scope of the variable. But in a 
for
loop, the initializer expression
is evaluated outside the scope of the new variable. This matters only when the new
variable is shadowing a new variable by the same name:
let x = 1;
for(let x = x + 1; x < 5; x++) 
console.log(x); // Prints 2,3,4
270 | Chapter 11: JavaScript Subsets and Extensions
                  // Begin a block to create a new variable scope
let x = x + 1;  // x is undefined, so x+1 is NaN
console.log(x); // Prints NaN
}
Variables declared with 
var
exist throughout the function in which they are declared,
but they are not initialized until the 
var
statement actually runs. That is, the variable
exists (i.e., no 
ReferenceError
will be thrown) but is 
undefined
if you attempt to use it
before the 
var
statement. Variables declared with 
let
are similar: if you attempt to use
a variable before its 
let
statement (but within the same block as the 
let
statement), the
variable will exist but its value will be 
undefined
.
Notice that this problem doesn’t exist when you use 
let
to declare a loop variable—
the syntax simply doesn’t allow you to use the variable before it is initialized. There is
another way to use 
let
that avoids this problem of using variables before they are
initialized. A 
let
block statement (as opposed to the 
let
declaration statements shown
above) combines a block of code with a set of variables for the block and the initiali-
zation expressions for those variables. In this form, the variables and their initializers
are placed within parentheses and are followed by a block of statements within curly
braces:
let x=1, y=2;
let (x=x+1,y=x+2) {   // Note that we're shadowing variables
console.log(x+y); // Prints 5
};
console.log(x+y);     // Prints 3
It is important to understand that the variable initializer expressions of a 
let
block are
not part of the block and are interpreted in the outer scope. In the code above, we are
creating a new variable x and assigning it a value one larger than the value of the existing
variable x.
The final use of the 
let
keyword is a variant on the 
let
block, in which a parenthesized
list of variables and initializers is followed by a single expression rather than a block of
statements. This is called a 
let
expression, and the code above could be rewritten to
use one like this:
let x=1, y=2;
console.log(let (x=x+1,y=x+2) x+y);  // Prints 5
Some form of 
const
and 
let
(not necessarily all four forms described here) are likely to
be included in a future version of the ECMAScript standard.
11.3  Destructuring Assignment
Spidermonkey 1.7 implements a kind of compound assignment known as destructuring
assignment. (You may have seen destructuring assignment before, in Python or Ruby,
for example.) In a destructuring assignment, the value on the right-hand side of the
equals sign is an array or object (a “structured” value) and the left-hand side specifies
one or more variable names using a syntax that mimics array and object literal syntax.
11.3  Destructuring Assignment | 271
Core JavaScript
When a destructuring assignment occurs, one or more values are extracted (“destruc-
tured”) from the value on the right and stored into the variables named on the left. In
addition to its use with the regular assignment operator, destructuring assignment can
also be used when initializing newly declared variables with 
var
and 
let
.
Destructuring assignment is simple and powerful when working with arrays, and is
particularly useful with functions that return arrays of values. It can become confusing
and complex when used with objects and nested objects, however. Examples demon-
strating both simple and complex uses follow.
Here are simple destructuring assignments using arrays of values:
let [x,y] = [1,2];    // Same as let x=1, y=2
[x,y] = [x+1,y+1];    // Same as x = x + 1, y = y+1
[x,y] = [y,x];        // Swap the value of the two variables
console.log([x,y]);   // Prints [3,2]
Notice how destructuring assignment makes it easy to work with functions that return
arrays of values:
// Convert [x,y] coordinates to [r,theta] polar coordinates
function polar(x,y) {
return [Math.sqrt(x*x+y*y), Math.atan2(y,x)];
}
// Convert polar to Cartesian coordinates
function cartesian(r,theta) {
return [r*Math.cos(theta), r*Math.sin(theta)];
}
let [r,theta] = polar(1.0, 1.0);  // r=Math.sqrt(2), theta=Math.PI/4
let [x,y] = cartesian(r,theta);   // x=1.0, y=1.0
The number of variables on the left of a destructuring assignment does not have to
match the number of array elements on the right. Extra variables on the left are set to
undefined
, and extra values on the right are ignored. The list of variables on the left can
include extra commas to skip certain values on the right:
let [x,y] = [1];     // x = 1, y = undefined
[x,y] = [1,2,3];     // x = 1, y = 2
[,x,,y] = [1,2,3,4]; // x = 2, y = 4
There is no syntax to assign all unused or remaining values (as an array) to a variable.
In the second line of code above, for example, there is no way to assign 
[2,3]
to 
y
.
The value of a destructuring assignment is the complete data structure on the right-
hand side, not the individual values that are extracted from it. Thus, it is possible to
“chain” assignments like this:
let first, second, all;
all = [first,second] = [1,2,3,4]; // first=1, second=2, all=[1,2,3,4]
Destructuring assignment can even be used with nested arrays. In this case, the left-
hand side of the assignment should look like a nested array literal:
let [one, [twoA, twoB]] = [1, [2,2.5], 3]; // one=1, twoA=2, twoB=2.5
272 | Chapter 11: JavaScript Subsets and Extensions
Documents you may be interested
Documents you may be interested