Another critical difference between Example 9-1 and Example 9-2 is the way the pro-
totype object is named. In the first example, the prototype was 
range.methods
. This was
a convenient and descriptive name, but arbitrary. In the second example, the prototype
is 
Range.prototype
, and this name is mandatory. An invocation of the 
Range()
con-
structor automatically uses 
Range.prototype
as the prototype of the new Range object.
Finally, also note the things that do not change between Example 9-1 and Exam-
ple 9-2: the range methods are defined and invoked in the same way for both classes.
9.2.1  Constructors and Class Identity
As we’ve seen, the prototype object is fundamental to the identity of a class: two objects
are instances of the same class if and only if they inherit from the same prototype object.
The constructor function that initializes the state of a new object is not fundamental:
two constructor functions may have 
prototype
properties that point to the same pro-
totype object. Then both constructors can be used to create instances of the same class.
Even through constructors are not as fundamental as prototypes, the constructor serves
as the public face of a class. Most obviously, the name of the constructor function is
usually adopted as the name of the class. We say, for example, that the 
Range()
con-
structor creates Range objects. More fundamentally, however, constructors are used
with the 
instanceof
operator when testing objects for membership in a class. If we have
an object 
r
and want to know if it is a Range object, we can write:
r instanceof Range   // returns true if r inherits from Range.prototype
The 
instanceof
operator does not actually check whether 
r
was initialized by the
Range
constructor. It checks whether it inherits from 
Range.prototype
. Nevertheless,
the 
instanceof
syntax reinforces the use of constructors as the public identity of a class.
We’ll see the 
instanceof
operator again later in this chapter.
9.2.2  The constructor Property
In Example 9-2 we set 
Range.prototype
to a new object that contained the methods for
our class. Although it was convenient to express those methods as properties of a single
object literal, it was not actually necessary to create a new object. Any JavaScript
function can be used as a constructor, and constructor invocations need a 
prototype
property. Therefore, every JavaScript function (except functions returned by the EC-
MAScript 5 
Function.bind()
method) automatically has a 
prototype
property. The val-
ue of this property is an object that has a single nonenumerable 
constructor
property.
The value of the 
constructor
property is the function object:
var F = function() {}; // This is a function object. 
var p = F.prototype;   // This is the prototype object associated with it.
var c = p.constructor; // This is the function associated with the prototype.
c === F                // => true: F.prototype.constructor==F for any function
9.2  Classes and Constructors | 203
Core JavaScript
Pdf link to email - 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 links to pdf in preview; add hyperlinks pdf file
Pdf link to email - 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 email link to pdf; add hyperlink to pdf online
The existence of this predefined prototype object with its 
constructor
property means
that objects typically inherit a 
constructor
property that refers to their constructor.
Since constructors serve as the public identity of a class, this constructor property gives
the class of an object:
var o = new F();      // Create an object o of class F
o.constructor === F   // => true: the constructor property specifies the class
Figure 9-1 illustrates this relationship between the constructor function, its prototype
object, the back reference from the prototype to the constructor, and the instances
created with the constructor.
Figure 9-1. A constructor function, its prototype, and instances
Notice that Figure 9-1 uses our 
Range()
constructor as an example. In fact, however,
the Range class defined in Example 9-2 overwrites the predefined 
Range.prototype
ob-
ject with an object of its own. And the new prototype object it defines does not have a
constructor
property. So instances of the Range class, as defined, do not have a 
con
structor
property. We can remedy this problem by explicitly adding a constructor to
the prototype:
Range.prototype = {
constructor: Range,  // Explicitly set the constructor back-reference
includes: function(x) { return this.from <= x && x <= this.to; },
foreach: function(f) {
for(var x = Math.ceil(this.from); x <= this.to; x++) f(x);
},
toString: function() { return "(" + this.from + "..." + this.to + ")"; }
};
Another common technique is to use the predefined prototype object with its
constructor
property, and add methods to it one at a time:
// Extend the predefined Range.prototype object so we don't overwrite
// the automatically created Range.prototype.constructor property.
Range.prototype.includes = function(x) { return this.from<=x && x<=this.to; };
Range.prototype.foreach = function(f) {
for(var x = Math.ceil(this.from); x <= this.to; x++) f(x);
};
Range.prototype.toString = function() {
return "(" + this.from + "..." + this.to + ")";
};
204 | Chapter 9: Classes and Modules
RasterEdge.com General FAQs for Products
copy and email the secure download link to the assistance, please contact us via email (support@rasteredge & profession imaging controls, PDF document, image to
add links to pdf in preview; clickable links in pdf from word
RasterEdge Product Licensing Discount
s). After confirming the informations provided, we will send you an email that contains price(s) at a discount and the online order link for new licensing.
add hyperlink pdf document; pdf link open in new window
9.3  Java-Style Classes in JavaScript
If you have programmed in Java or a similar strongly-typed object-oriented language,
you may be accustomed to thinking about four kinds of class members:
Instance fields
These are the per-instance properties or variables that hold the state of individual
objects.
Instance methods
These are methods that are shared by all instances of the class that are invoked
through individual instances.
Class fields
These are properties or variables associated with the class rather than the instances
of the class.
Class methods
These are methods that are associated with the class rather than with instances.
One way JavaScript differs from Java is that its functions are values, and there is no
hard distinction between methods and fields. If the value of a property is a function,
that property defines a method; otherwise, it is just an ordinary property or “field.”
Despite this difference, we can simulate each of Java’s four categories of class members
in JavaScript. In JavaScript, there are three different objects involved in any class defi-
nition (see Figure 9-1), and the properties of these three objects act like different kinds
of class members:
Constructor object
As we’ve noted, the constructor function (an object) defines a name for a JavaScript
class. Properties you add to this constructor object serve as class fields and class
methods (depending on whether the property values are functions or not).
Prototype object
The properties of this object are inherited by all instances of the class, and prop-
erties whose values are functions behave like instance methods of the class.
Instance object
Each instance of a class is an object in its own right, and properties defined directly
on an instance are not shared by any other instances. Nonfunction properties de-
fined on instances behave as the instance fields of the class.
We can reduce the process of class definition in JavaScript to a three-step algorithm.
First, write a constructor function that sets instance properties on new objects. Second,
define instance methods on the 
prototype
object of the constructor. Third, define class
fields and class properties on the constructor itself. We can even implement this algo-
rithm as a simple 
defineClass()
function. (It uses the 
extend()
function of Exam-
ple 6-2 as patched in Example 8-3):
// A simple function for defining simple classes
function defineClass(constructor,  // A function that sets instance properties
9.3  Java-Style Classes in JavaScript | 205
Core JavaScript
RasterEdge Product Renewal and Update
4. Order email. Our support team will send you the purchase link. HTML5 Viewer for .NET; XDoc.Windows Viewer for .NET; XDoc.Converter for .NET; XDoc.PDF for .NET;
adding hyperlinks to pdf files; adding hyperlinks to pdf documents
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Create PDF file from PowerPoint free online without email.
add links to pdf in acrobat; pdf link
methods,      // Instance methods: copied to prototype
statics)      // Class properties: copied to constructor
{
if (methods) extend(constructor.prototype, methods);
if (statics) extend(constructor, statics);
return constructor;
}
// This is a simple variant of our Range class
var SimpleRange =
defineClass(function(f,t) { this.f = f; this.t = t; },
{
includes: function(x) { return this.f <= x && x <= this.t;},
toString: function() { return this.f + "..." + this.t; }
},
{ upto: function(t) { return new SimpleRange(0, t); } });
Example 9-3 is a longer class definition. It creates a class that represents complex num-
bers and demonstrates how to simulate Java-style class members using JavaScript. It
does this “manually”—without relying on the 
defineClass()
function above.
Example 9-3. Complex.js: A complex number class
/*
* Complex.js:
* This file defines a Complex class to represent complex numbers.
* Recall that a complex number is the sum of a real number and an
* imaginary number and that the imaginary number i is the square root of -1.
*/
/*
* This constructor function defines the instance fields r and i on every
* instance it creates.  These fields hold the real and imaginary parts of
* the complex number: they are the state of the object.
*/
function Complex(real, imaginary) {
if (isNaN(real) || isNaN(imaginary)) // Ensure that both args are numbers.
throw new TypeError();           // Throw an error if they are not.
this.r = real;                       // The real part of the complex number.
this.i = imaginary;                  // The imaginary part of the number.
}
/*
* The instance methods of a class are defined as function-valued properties
* of the prototype object.  The methods defined here are inherited by all
* instances and provide the shared behavior of the class. Note that JavaScript
* instance methods must use the this keyword to access the instance fields.
*/
// Add a complex number to this one and return the sum in a new object.
Complex.prototype.add = function(that) {
return new Complex(this.r + that.r, this.i + that.i);
};
// Multiply this complex number by another and return the product.
Complex.prototype.mul = function(that) {
206 | Chapter 9: Classes and Modules
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Free online Word to PDF converter without email.
add links pdf document; add hyperlink pdf file
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Convert Excel to PDF document free online without email.
pdf edit hyperlink; add links to pdf online
return new Complex(this.r * that.r - this.i * that.i,
this.r * that.i + this.i * that.r);
};
// Return the real magnitude of a complex number. This is defined
// as its distance from the origin (0,0) of the complex plane.
Complex.prototype.mag = function() {
return Math.sqrt(this.r*this.r + this.i*this.i);
};
// Return a complex number that is the negative of this one.
Complex.prototype.neg = function() { return new Complex(-this.r, -this.i); };
// Convert a Complex object to a string in a useful way.
Complex.prototype.toString = function() {
return "{" + this.r + "," + this.i + "}";
};
// Test whether this Complex object has the same value as another.
Complex.prototype.equals = function(that) {
return that != null &&                      // must be defined and non-null
that.constructor === Complex &&         // and an instance of Complex 
this.r === that.r && this.i === that.i; // and have the same values.
};
/*
* Class fields (such as constants) and class methods are defined as 
* properties of the constructor. Note that class methods do not 
* generally use the this keyword: they operate only on their arguments.
*/
// Here are some class fields that hold useful predefined complex numbers.
// Their names are uppercase to indicate that they are constants.
// (In ECMAScript 5, we could actually make these properties read-only.)
Complex.ZERO = new Complex(0,0);
Complex.ONE = new Complex(1,0);
Complex.I = new Complex(0,1);
// This class method parses a string in the format returned by the toString
// instance method and returns a Complex object or throws a TypeError.
Complex.parse = function(s) {
try {          // Assume that the parsing will succeed
var m = Complex._format.exec(s);  // Regular expression magic
return new Complex(parseFloat(m[1]), parseFloat(m[2]));
} catch (x) {  // And throw an exception if it fails
throw new TypeError("Can't parse '" + s + "' as a complex number.");
}
};
// A "private" class field used in Complex.parse() above.
// The underscore in its name indicates that it is intended for internal
// use and should not be considered part of the public API of this class.
Complex._format = /^\{([^,]+),([^}]+)\}$/;
9.3  Java-Style Classes in JavaScript | 207
Core JavaScript
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
Create editable Word file online without email. Supports transfer from password protected PDF. VB.NET class source code for .NET framework.
adding hyperlinks to a pdf; add links in pdf
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
and .docx. Create editable Word file online without email. Password protected PDF file can be printed to Word for mail merge. C# source
clickable links in pdf files; c# read pdf from url
With the Complex class of Example 9-3 defined, we can use the constructor, instance
fields, instance methods, class fields, and class methods with code like this:
var c = new Complex(2,3);     // Create a new object with the constructor
var d = new Complex(c.i,c.r); // Use instance properties of c
c.add(d).toString();          // => "{5,5}": use instance methods
// A more complex expression that uses a class method and field
Complex.parse(c.toString()).  // Convert c to a string and back again,
add(c.neg()).             // add its negative to it,
equals(Complex.ZERO)      // and it will always equal zero
Although JavaScript classes can emulate Java-style class members, there are a number
of significant Java features that JavaScript classes do not support. First, in the instance
methods of Java classes, instance fields can be used as if they were local variables—
there is no need to prefix them with 
this
. JavaScript does not do this, but you could
achieve a similar effect using a 
with
statement (this is not recommended, however):
Complex.prototype.toString = function() {
with(this) {
return "{" + r + "," + i + "}";
}
};
Java allows fields to be declared 
final
to indicate that they are constants, and it allows
fields and methods to be declared 
private
to specify that they are private to the class
implementation and should not be visible to users of the class. JavaScript does not have
these keywords, and Example 9-3 uses typographical conventions to provide hints that
some properties (whose names are in capital letters) should not be changed and that
others (whose names begin with an underscore) should not be used outside of the class.
We’ll return to both of these topics later in the chapter: private properties can be emu-
lated using the local variables of a closure (see §9.6.6) and constant properties are
possible in ECMAScript 5 (see §9.8.2).
9.4  Augmenting Classes
JavaScript’s prototype-based inheritance mechanism is dynamic: an object inherits
properties from its prototype, even if the prototype changes after the object is created.
This means that we can augment JavaScript classes simply by adding new methods to
their prototype objects. Here is code that adds a method for computing the complex
conjugate to the Complex class of Example 9-3:
// Return a complex number that is the complex conjugate of this one.
Complex.prototype.conj = function() { return new Complex(this.r, -this.i); };
The prototype object of built-in JavaScript classes is also “open” like this, which means
that we can add methods to numbers, strings, arrays, functions, and so on. We did this
in Example 8-5 when we added a 
bind()
method to the  function class in
ECMAScript 3 implementations where it did not already exist:
if (!Function.prototype.bind) {
Function.prototype.bind = function(o /*, args */) {
208 | Chapter 9: Classes and Modules
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Export PDF from Excel with cell border or no border. Free online Excel to PDF converter without email. Quick integrate online C# source code into .NET class.
add url to pdf; add link to pdf
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
application. Free online PowerPoint to PDF converter without email. C# source code is provided for .NET WinForms class. Evaluation
add link to pdf acrobat; add links to pdf acrobat
// Code for the bind method goes here...
};
}
Here are some other examples:
// Invoke the function f this many times, passing the iteration number
// For example, to print "hello" 3 times:
//     var n = 3;
//     n.times(function(n) { console.log(n + " hello"); });
Number.prototype.times = function(f, context) {
var n = Number(this);
for(var i = 0; i < n; i++) f.call(context, i);
};
// Define the ES5 String.trim() method if one does not already exist.
// This method returns a string with whitespace removed from the start and end.
String.prototype.trim = String.prototype.trim || function() {
if (!this) return this;                // Don't alter the empty string
return this.replace(/^\s+|\s+$/g, ""); // Regular expression magic
};
// Return a function's name.  If it has a (nonstandard) name property, use it.
// Otherwise, convert the function to a string and extract the name from that.
// Returns an empty string for unnamed functions like itself.
Function.prototype.getName = function() {
return this.name || this.toString().match(/function\s*([^(]*)\(/)[1];
};
It is possible to add methods to 
Object.prototype
, making them available on all objects.
This is not recommended, however, because prior to ECMAScript 5, there is no way
to make these add-on methods nonenumerable, and if you add properties to 
Object.pro
totype
, those properties will be reported by all 
for/in
loops. In §9.8.1 we’ll see an
example of using the ECMAScript 5 method 
Object.defineProperty()
to safely aug-
ment 
Object.prototype
.
It is implementation-dependent whether classes defined by the host environment (such
as the web browser) can be augmented in this way. In many web browsers, for example,
you can add methods to 
HTMLElement.prototype
and those methods will be inherited
by the objects that represent the HTML tags in the current document. This does not
work in current versions of Microsoft’s Internet Explorer, however, which severely
limits the utility of this technique for client-side programming.
9.5  Classes and Types
Recall from Chapter 3 that JavaScript defines a small set of types: null, undefined,
boolean, number, string, function, and object. The 
typeof
operator (§4.13.2) allows
us to distinguish among these types. Often, however, it is useful to treat each class as
its own type and to be able to distinguish objects based on their class. The built-in
objects of core JavaScript (and often the host objects of client-side JavaScript) can be
distinguished on the basis of their class attribute (§6.8.2) using code like the
9.5  Classes and Types | 209
Core JavaScript
classof()
function of Example 6-4. But when we define our own classes using the
techniques shown in this chapter, the instance objects always have a class attribute of
“Object”, so the 
classof()
function doesn’t help here.
The subsections that follow explain three techniques for determining the class of an
arbitrary object: the 
instanceof
operator, the 
constructor
property, and the name of
the constructor function. None of these techniques is entirely satisfactory, however,
and the section concludes with a discussion of duck-typing, a programming philosophy
that focuses on what an object can do (what methods it has) rather than what its
class is.
9.5.1  The instanceof operator
The 
instanceof
operator was described in §4.9.4. The left-hand operand should be the
object whose class is being tested, and the right-hand operand should be a constructor
function that names a class. The expression 
o instanceof c
evaluates to 
true
if 
o
inherits
from 
c.prototype
. The inheritance need not be direct. If 
o
inherits from an object that
inherits from an object that inherits from 
c.prototype
, the expression will still evaluate
to 
true
.
As noted earlier in this chapter, constructors act as the public identity of classes, but
prototypes are the fundamental identity. Despite the use of a constructor function with
instanceof
, this operator is really testing what an object inherits from, not what con-
structor was used to create it.
If you want to test the prototype chain of an object for a specific prototype object and
do not want to use the constructor function as an intermediary, you can use the
isPrototypeOf()
method. For example, we could test whether an object 
r
was a member
of the range class defined in Example 9-1 with this code:
range.methods.isPrototypeOf(r);  // range.methods is the prototype object.
One shortcoming of the 
instanceof
operator and the 
isPrototypeOf()
method is that
they do not allow us to query the class of an object, only to test an object against a class
we specify. A more serious shortcoming arises in client-side JavaScript where a web
application uses more than one window or frame. Each window or frame is a distinct
execution context, and each has its own global object and its own set of constructor
functions. Two arrays created in two different frames inherit from two identical but
distinct prototype objects, and an array created in one frame is not 
instanceof
the
Array()
constructor of another frame.
210 | Chapter 9: Classes and Modules
9.5.2  The constructor property
Another way to identify the class of an object is to simply use the 
constructor
property.
Since constructors are the public face of classes, this is a straightforward approach. For
example:
function typeAndValue(x) {
if (x == null) return "";  // Null and undefined don't have constructors
switch(x.constructor) {
case Number:  return "Number: " + x;         // Works for primitive types
case String:  return "String: '" + x + "'";
case Date:    return "Date: " + x;           // And for built-in types
case RegExp:  return "Regexp: " + x;
case Complex: return "Complex: " + x;        // And for user-defined types
}
}
Note that the expressions following the 
case
keyword in the code above are functions.
If we were using the 
typeof
operator or extracting the class attribute of the object, they
would be strings instead.
This technique of using the 
constructor
property is subject to the same problem as
instanceof
. It won’t always work when there are multiple execution contexts (such as
multiple frames in a browser window) that share values. In this situation, each frame
has its own set of constructor functions: the 
Array
constructor in one frame is not the
same as the 
Array
constructor in another frame.
Also, JavaScript does not require that every object have a 
constructor
property: this is
a convention based on the default prototype object created for each function, but it is
easy to accidentally or intentionally omit the 
constructor
property on the prototype.
The first two classes in this chapter, for example, were defined in such a way (in
Examples 9-1 and 9-2) that their instances did not have 
constructor
properties.
9.5.3  The Constructor Name
The main problem with using the 
instanceof
operator or the 
constructor
property for
determining the class of an object occurs when there are multiple execution contexts
and thus multiple copies of the constructor functions. These functions may well be
identical, but they are distinct objects and are therefore not equal to each other.
One possible workaround is to use the name of the constructor function as the class
identifier rather than the function itself. The 
Array
constructor in one window is not
equal to the 
Array
constructor in another window, but their names are equal. Some
JavaScript implementations make the name of a function available through a nonstan-
dard 
name
property of the function object. For implementations without a 
name
property,
we can convert the function to a string and extract the name from that. (We did this in
§9.4 when we showed how to add a 
getName()
method to the Function class.)
Example 9-4 defines a 
type()
function that returns the type of an object as a string. It
handles primitive values and functions with the 
typeof
operator. For objects, it returns
9.5  Classes and Types | 211
Core JavaScript
either the value of the class attribute or the name of the constructor. The 
type()
function
uses the 
classof()
function from Example 6-4 and the 
Function.getName()
method
from §9.4. The code for that function and method are included here for simplicity.
Example 9-4. A type() function to determine the type of a value
/**
* Return the type of o as a string:
*   -If o is null, return "null", if o is NaN, return "nan".
*   -If typeof returns a value other than "object" return that value.
*    (Note that some implementations identify regexps as functions.)
*   -If the class of o is anything other than "Object", return that.
*   -If o has a constructor and that constructor has a name, return it.
*   -Otherwise, just return "Object".
**/
function type(o) {
var t, c, n;  // type, class, name
// Special case for the null value:
if (o === null) return "null";
// Another special case: NaN is the only value not equal to itself:
if (o !== o) return "nan";
// Use typeof for any value other than "object".
// This identifies any primitive value and also functions.
if ((t = typeof o) !== "object") return t;
// Return the class of the object unless it is "Object".
// This will identify most native objects.
if ((c = classof(o)) !== "Object") return c;
// Return the object's constructor name, if it has one
if (o.constructor && typeof o.constructor === "function" &&
(n = o.constructor.getName())) return n;
// We can't determine a more specific type, so return "Object"
return "Object";
}
// Return the class of an object.
function classof(o) {
return Object.prototype.toString.call(o).slice(8,-1);
};
// Return the name of a function (may be "") or null for nonfunctions
Function.prototype.getName = function() {
if ("name" in this) return this.name;
return this.name = this.toString().match(/function\s*([^(]*)\(/)[1];
};
This technique of using the constructor name to identify the class of an object has one
of the same problems as using the 
constructor
property itself: not all objects have a
constructor
property. Furthermore, not all functions have a name. If we define a
212 | Chapter 9: Classes and Modules
Documents you may be interested
Documents you may be interested