open pdf and draw c# : C# read pdf from url SDK application service wpf html azure dnn %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D5-part1581

3.1.3  Arithmetic in JavaScript
JavaScript programs work with numbers using the arithmetic operators that the lan-
guage  provides.  These  include 
+
for  addition, 
-
for  subtraction, 
*
for  multiplica-
tion, 
/
for division, and 
%
for modulo (remainder after division). Full details on these
and other operators can be found in Chapter 4.
In addition to  these basic  arithmetic  operators, JavaScript supports more  complex
mathematical operations through a set of functions and constants defined as properties
of the 
Math
object:
Math.pow(2,53)           // => 9007199254740992: 2 to the power 53
Math.round(.6)           // => 1.0: round to the nearest integer
Math.ceil(.6)            // => 1.0: round up to an integer
Math.floor(.6)           // => 0.0: round down to an integer
Math.abs(-5)             // => 5: absolute value
Math.max(x,y,z)          // Return the largest argument
Math.min(x,y,z)          // Return the smallest argument
Math.random()            // Pseudo-random number x where 0 <= x < 1.0
Math.PI                  // π: circumference of a circle / diameter
Math.E                   // e: The base of the natural logarithm
Math.sqrt(3)             // The square root of 3
Math.pow(3, 1/3)         // The cube root of 3
Math.sin(0)              // Trigonometry: also Math.cos, Math.atan, etc.
Math.log(10)             // Natural logarithm of 10
Math.log(100)/Math.LN10  // Base 10 logarithm of 100
Math.log(512)/Math.LN2   // Base 2 logarithm of 512
Math.exp(3)              // Math.E cubed
See the Math object in the reference section for complete details on all the mathematical
functions supported by JavaScript.
Arithmetic in JavaScript does not raise errors in cases of overflow, underflow, or divi-
sion by zero. When the result of a numeric operation is larger than the largest repre-
sentable number (overflow), the result is a special infinity value, which JavaScript prints
as 
Infinity
. Similarly, when a negative value becomes larger than the largest repre-
sentable negative number, the result is negative infinity, printed as 
-Infinity
. The in-
finite values behave as you would expect: adding, subtracting, multiplying, or dividing
them by anything results in an infinite value (possibly with the sign reversed).
Underflow occurs when the result of a numeric operation is closer to zero than the
smallest representable number. In this case, JavaScript returns 0. If underflow occurs
from a negative number, JavaScript returns a special value known as “negative zero.”
This value is almost completely indistinguishable  from regular zero and JavaScript
programmers rarely need to detect it.
Division by zero is not an error in JavaScript: it simply returns infinity or negative
infinity. There is one exception, however: zero divided by zero does not have a well-
defined value, and the result of this operation is the special not-a-number value, printed
as 
NaN
NaN
also arises if you attempt to divide infinity by infinity, or take the square
3.1  Numbers | 33
Core JavaScript
C# read pdf from url - 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 hyperlinks to pdf online; add hyperlink to pdf acrobat
C# read pdf from url - 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; adding hyperlinks to pdf files
root of a negative number or use arithmetic operators with non-numeric operands that
cannot be converted to numbers.
JavaScript predefines global variables 
Infinity
and 
NaN
to hold the positive infinity and
not-a-number value. In ECMAScript 3, these are read/write values and can be changed.
ECMAScript 5 corrects this and makes the values read-only. The 
Number
object defines
alternatives that are read-only even in ECMAScript 3. Here are some examples:
Infinity                    // A read/write variable initialized to Infinity.
Number.POSITIVE_INFINITY    // Same value, read-only.
1/0                         // This is also the same value.
Number.MAX_VALUE + 1        // This also evaluates to Infinity.
Number.NEGATIVE_INFINITY    // These expressions are negative infinity.
-Infinity
-1/0                        
-Number.MAX_VALUE - 1
NaN                         // A read/write variable initialized to NaN.
Number.NaN                  // A read-only property holding the same value.
0/0                         // Evaluates to NaN.
Number.MIN_VALUE/2          // Underflow: evaluates to 0
-Number.MIN_VALUE/2         // Negative zero
-1/Infinity                 // Also negative 0
-0
The not-a-number value has one unusual feature in JavaScript: it does not compare
equal to any other value, including itself. This means that you can’t write 
x == NaN
to
determine whether the value of a variable 
x
is 
NaN
. Instead, you should write 
x != x
.
That expression will be true if, and only if, x is 
NaN
. The function 
isNaN()
is similar. It
returns 
true
if its argument is 
NaN
, or if that argument is a non-numeric value such as
a string or an object. The related function 
isFinite()
returns 
true
if its argument is a
number other than 
NaN
Infinity
, or -
Infinity
.
The negative zero value is also somewhat unusual. It compares equal (even using Java-
Script’s strict equality test) to positive zero, which means that the two values are almost
indistinguishable, except when used as a divisor:
var zero = 0;         // Regular zero
var negz = -0;        // Negative zero
zero === negz         // => true: zero and negative zero are equal 
1/zero === 1/negz     // => false: infinity and -infinity are not equal
3.1.4  Binary Floating-Point and Rounding Errors
There  are  infinitely  many  real  numbers,  but  only  a  finite  number  of  them
(18437736874454810627, to be exact) can be represented exactly by the JavaScript
floating-point format.  This means that when you’re working  with real numbers in
JavaScript, the representation of the number will often be an approximation of the
actual number.
34 | Chapter 3: Types, Values, and Variables
How to C#: Basic SDK Concept of XDoc.PDF for .NET
XDoc.PDF for .NET allows C# developers to edit hyperlink of PDF document, including editing PDF url links and quick navigation link in bookmark/outline.
add url link to pdf; add hyperlinks pdf file
C#: How to Open a File from a URL (HTTP, FTP) in HTML5 Viewer
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB Imaging, VB.NET OCR, VB.NET Twain, VB.NET Barcode Read, VB.NET C# HTML5 Viewer: Open a File from a URL.
pdf link open in new window; clickable links in pdf files
The IEEE-754 floating-point representation used by JavaScript (and just about every
other modern programming language) is a binary representation, which can exactly
represent fractions like 
1/2
1/8
, and 
1/1024
. Unfortunately, the fractions we use most
commonly (especially when performing financial calculations) are decimal fractions
1/10
1/100
, and so on. Binary floating-point representations cannot exactly represent
numbers as simple as 
0.1
.
JavaScript numbers have plenty of precision and can approximate 
0.1
very closely. But
the fact that this number cannot be represented exactly can lead to problems. Consider
this code:
var x = .3 - .2;    // thirty cents minus 20 cents
var y = .2 - .1;    // twenty cents minus 10 cents
x == y              // => false: the two values are not the same!
x == .1             // => false: .3-.2 is not equal to .1
y == .1             // => true: .2-.1 is equal to .1
Because of rounding error, the difference between the approximations of .3 and .2 is
not exactly the same as the difference between the approximations of .2 and .1. It is
important to understand that this problem is not specific to JavaScript: it affects any
programming language that uses binary floating-point numbers. Also, note that the
values 
x
and 
y
in the code above are very close to each other and to the correct value.
The computed values are adequate for almost any purpose: the problem arises when
we attempt to compare values for equality.
A future version of JavaScript may support a decimal numeric type that avoids these
rounding issues. Until then you might want to perform critical financial calculations
using scaled integers. For example, you might manipulate monetary values as integer
cents rather than fractional dollars.
3.1.5  Dates and Times
Core JavaScript includes a 
Date()
constructor for creating objects that represent dates
and times. These Date objects have methods that provide an API for simple date com-
putations. Date objects are  not a fundamental type  like numbers are. This section
presents a quick tutorial on working with dates. Full details can be found in the refer-
ence section:
var then = new Date(2010, 0, 1);  // The 1st day of the 1st month of 2010
var later = new Date(2010, 0, 1,  // Same day, at 5:10:30pm, local time
17, 10, 30);
var now = new Date();          // The current date and time
var elapsed = now - then;      // Date subtraction: interval in milliseconds 
later.getFullYear()            // => 2010
later.getMonth()               // => 0: zero-based months
later.getDate()                // => 1: one-based days
later.getDay()                 // => 5: day of week.  0 is Sunday 5 is Friday.
later.getHours()               // => 17: 5pm, local time
later.getUTCHours()            // hours in UTC time; depends on timezone
3.1  Numbers | 35
Core JavaScript
XDoc.HTML5 Viewer, Create Web Doc & Image Viewer in C#.NET
Imaging, VB.NET OCR, VB.NET Twain, VB.NET Barcode Read, VB.NET C# Demo Codes for PDF Conversions. 2. Add web document viewer into your C# project aspx web page.
accessible links in pdf; add hyperlink to pdf
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
VB.NET OCR, VB.NET Twain, VB.NET Barcode Read, VB.NET C# PDF - View PDF Online with C#.NET HTML5 PDF Viewer. Able to load PDF document from file formats and url.
c# read pdf from url; adding links to pdf in preview
later.toString()               // => "Fri Jan 01 2010 17:10:30 GMT-0800 (PST)"
later.toUTCString()            // => "Sat, 02 Jan 2010 01:10:30 GMT"
later.toLocaleDateString()     // => "01/01/2010"
later.toLocaleTimeString()     // => "05:10:30 PM"
later.toISOString()            // => "2010-01-02T01:10:30.000Z"; ES5 only
3.2  Text
A string is an immutable ordered sequence of 16-bit values, each of which typically
represents a Unicode character—strings are JavaScript’s type for representing text. The
length of a string is the number of 16-bit values it contains. JavaScript’s strings (and its
arrays) use zero-based indexing: the first 16-bit value is at position 0, the second at
position 1 and so on. The empty string is the string of length 0. JavaScript does not have
a special type that represents a single element of a string. To represent a single 16-bit
value, simply use a string that has a length of 1.
Characters, Codepoints, and JavaScript Strings
JavaScript uses the UTF-16 encoding of the Unicode character set, and JavaScript
strings are sequences of unsigned 16-bit values. The most commonly used Unicode
characters (those from the “basic  multilingual plane”) have codepoints that  fit in
16 bits and can be represented by a single element of a string. Unicode characters whose
codepoints do not fit in 16 bits are encoded following the rules of UTF-16 as a sequence
(known as a “surrogate pair”) of two 16-bit values. This means that a JavaScript string
of length 2 (two 16-bit values) might represent only a single Unicode character:
var p = "π"; // π is 1 character with 16-bit codepoint 0x03c0
var e = "e"; // e is 1 character with 17-bit codepoint 0x1d452
p.length     // => 1: p consists of 1 16-bit element
e.length     // => 2: UTF-16 encoding of e is 2 16-bit values: "\ud835\udc52"
The various string-manipulation methods defined by JavaScript operate on 16-bit val-
ues, not on characters. They do not treat surrogate pairs specially, perform no normal-
ization of the string, and do not even ensure that a string is well-formed UTF-16.
3.2.1  String Literals
To include a string literally in a JavaScript program, simply enclose the characters of
the string within a matched pair of single or double quotes (
'
or 
"
). Double-quote
characters may be contained within strings delimited by single-quote characters, and
single-quote characters may be contained within strings delimited by double quotes.
Here are examples of string literals:
""  // The empty string: it has zero characters
'testing'
"3.14"
'name="myform"'
"Wouldn't you prefer O'Reilly's book?"
"This string\nhas two lines"
"π is the ratio of a circle's circumference to its diameter"
36 | Chapter 3: Types, Values, and Variables
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
PDF. |. Home ›› XDoc.PDF ›› C# PDF: Extract PDF Image. A powerful C#.NET PDF control compatible with windows operating system and built on .NET framework.
add a link to a pdf in preview; convert doc to pdf with hyperlinks
C# PDF Text Extract Library: extract text content from PDF file in
XDoc.PDF ›› C# PDF: Extract PDF Text. C# PDF - Extract Text from PDF in C#.NET. Best C#.NET PDF text extraction library and component for free download.
pdf link to attached file; add hyperlink to pdf in
In ECMAScript 3, string literals must be written on a single line. In ECMAScript 5,
however, you can break a string literal across multiple lines by ending each line but the
last with a backslash (
\
). Neither the backslash nor the line terminator that follow it
are part of the string literal. If you need to include a newline character in a string literal,
use the character sequence 
\n
(documented below):
"two\nlines"   // A string representing 2 lines written on one line
"one\          // A one-line string written on 3 lines. ECMAScript 5 only.
long\
line"
Note that when you use single quotes to delimit your strings, you must be careful with
English contractions and possessives, such as can’t and O’Reilly’s. Since the apostrophe
is the same as the single-quote character, you must use the backslash character (
\
) to
“escape” any apostrophes that appear in single-quoted strings (escapes are explained
in the next section).
In client-side JavaScript programming, JavaScript code may contain strings of HTML
code, and HTML code may contain strings of JavaScript code. Like JavaScript, HTML
uses either single or double quotes to delimit its strings. Thus, when combining Java-
Script and HTML, it is a good idea to use one style of quotes for JavaScript and the
other style for HTML. In the following example, the string “Thank you” is single-
quoted  within  a  JavaScript  expression,  which  is  then  double-quoted  within  an
HTML event-handler attribute:
<button onclick="alert('Thank you')">Click Me</button>
3.2.2  Escape Sequences in String Literals
The backslash character (
\
) has a special purpose in JavaScript strings. Combined with
the character that follows it, it represents a character that is not otherwise representable
within the string. For example, 
\n
is  an  escape  sequence that represents a  newline
character.
Another example, mentioned above, is the 
\'
escape, which represents the single quote
(or apostrophe) character. This escape sequence is useful when you need to include an
apostrophe in a string literal that is contained within single quotes. You can see why
these are called escape sequences: the backslash allows you to escape from the usual
interpretation of the single-quote character. Instead of using it to mark the end of the
string, you use it as an apostrophe:
'You\'re right, it can\'t be a quote'
Table 3-1 lists the JavaScript escape sequences and the characters they represent. Two
escape sequences are generic and can be used to represent any character by specifying
its Latin-1 or Unicode character code as a hexadecimal number. For example, the se-
quence 
\xA9
represents the copyright symbol, which has the Latin-1 encoding given by
the hexadecimal number A9. Similarly, the 
\u
escape represents an arbitrary Unicode
character  specified  by  four  hexadecimal  digits; 
\u03c0
represents  the  character  π,
for example.
3.2  Text | 37
Core JavaScript
C# PDF Library SDK to view, edit, convert, process PDF file for C#
for editing PDF document hyperlink (url) and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit
add a link to a pdf in acrobat; add hyperlink in pdf
VB.NET PDF: Basic SDK Concept of XDoc.PDF
XDoc.PDF for .NET allows VB.NET developers to edit hyperlink of PDF document, including editing PDF url links and quick navigation link in bookmark/outline.
add hyperlink pdf file; add hyperlink pdf document
Table 3-1. JavaScript escape sequences
Sequence Character represented
\0
The NUL character (
\u0000
)
\b
Backspace (
\u0008
)
\t
Horizontal tab (
\u0009
)
\n
Newline (
\u000A
)
\v
Vertical tab (
\u000B
)
\f
Form feed (
\u000C
)
\r
Carriage return (
\u000D
)
\"
Double quote (
\u0022
)
\'
Apostrophe or single quote (
\u0027
)
\\
Backslash (
\u005C
)
\x
XX
The Latin-1 character specified by the two hexadecimal digits 
XX
\u
XXXX
The Unicode character specified by the four hexadecimal digits 
XXXX
If the 
\
character precedes any character other than those shown in Table 3-1, the
backslash is simply ignored (although future versions of the language may, of course,
define new escape sequences). For example, 
\#
is the same as 
#
. Finally, as noted above,
ECMAScript 5 allows a backslash before a line break to break a string literal across
multiple lines.
3.2.3  Working with Strings
One of the built-in features of JavaScript is the ability to concatenate strings. If you use
the 
+
operator with numbers, it adds them. But if you use this operator on strings, it
joins them by appending the second to the first. For example:
msg = "Hello, " + "world";   // Produces the string "Hello, world"
greeting = "Welcome to my blog," + " " + name;
To determine the length of a string—the number of 16-bit values it contains—use the
length
property of the string. Determine the length of a string 
s
like this:
s.length
In addition to this 
length
property, there are a number of methods you can invoke on
strings (as always, see the reference section for complete details):
var s = "hello, world"        // Start with some text.
s.charAt(0)                   // => "h": the first character.
s.charAt(s.length-1)          // => "d": the last character.
s.substring(1,4)              // => "ell": the 2nd, 3rd and 4th characters.
s.slice(1,4)                  // => "ell": same thing
s.slice(-3)                   // => "rld": last 3 characters
s.indexOf("l")                // => 2: position of first letter l.
s.lastIndexOf("l")            // => 10: position of last letter l.
s.indexOf("l", 3)             // => 3: position of first "l" at or after 3
38 | Chapter 3: Types, Values, and Variables
s.split(", ")                 // => ["hello", "world"] split into substrings
s.replace("h", "H")           // => "Hello, world": replaces all instances
s.toUpperCase()               // => "HELLO, WORLD"
Remember  that  strings  are  immutable  in  JavaScript.  Methods  like 
replace()
and
toUpperCase()
return new strings: they do not modify the string on which they are
invoked.
In ECMAScript 5, strings can be treated like read-only arrays, and you can access in-
dividual characters (16-bit values) from a string using square brackets instead of the
charAt()
method:
s = "hello, world";
s[0]                  // => "h"
s[s.length-1]         // => "d"
Mozilla-based web browsers such as Firefox have allowed strings to be indexed in this
way for a long time. Most modern browsers (with the notable exception of IE) followed
Mozilla’s lead even before this feature was standardized in ECMAScript 5.
3.2.4  Pattern Matching
JavaScript defines a 
RegExp()
constructor for creating objects that represent textual
patterns. These patterns are described with regular expressions, and JavaScript adopts
Perl’s syntax for regular expressions. Both strings and RegExp objects have methods
for  performing  pattern  matching  and  search-and-replace  operations  using  regular
expressions.
RegExps are not one of the fundamental types of JavaScript. Like Dates, they are simply
a specialized kind of object, with a useful API. The regular expression grammar is com-
plex and the API is nontrivial. They are documented in detail in Chapter 10. Because
RegExps are powerful and commonly used for text processing, however, this section
provides a brief overview.
Although RegExps are not one of the fundamental data types in the language, they do
have a literal syntax and can be encoded directly into JavaScript programs. Text be-
tween a pair of slashes constitutes a regular expression literal. The second slash in the
pair can also be followed by one or more letters, which modify the meaning of the
pattern. For example:
/^HTML/              // Match the letters H T M L at the start of a string
/[1-9][0-9]*/        // Match a non-zero digit, followed by any # of digits
/\bjavascript\b/i    // Match "javascript" as a word, case-insensitive
RegExp objects define a number of useful methods, and strings also have methods that
accept RegExp arguments. For example:
var text = "testing: 1, 2, 3";   // Sample text
var pattern = /\d+/g             // Matches all instances of one or more digits
pattern.test(text)               // => true: a match exists
text.search(pattern)             // => 9: position of first match
text.match(pattern)              // => ["1", "2", "3"]: array of all matches
3.2  Text | 39
Core JavaScript
text.replace(pattern, "#");      // => "testing: #, #, #"
text.split(/\D+/);               // => ["","1","2","3"]: split on non-digits
3.3  Boolean Values
A boolean value represents truth or falsehood, on or off, yes or no. There are only two
possible values  of  this  type. The reserved words 
true
and 
false
evaluate  to  these
two values.
Boolean values are generally the result of comparisons you make in your JavaScript
programs. For example:
a == 4
This code tests to see whether the value of the variable 
a
is equal to the number 
4
. If it
is, the result of this comparison is the boolean value 
true
. If 
a
is not equal to 
4
, the result
of the comparison is 
false
.
Boolean values are commonly used in JavaScript control structures. For example, the
if/else
statement in JavaScript performs one action if a boolean value is 
true
and
another action if the value is 
false
. You usually combine a comparison that creates a
boolean value directly with a statement that uses it. The result looks like this:
if (a == 4)
b = b + 1;
else
a = a + 1;
This code checks whether 
a
equals 
4
. If so, it adds 
1
to 
b
; otherwise, it adds 
1
to 
a
.
As we’ll discuss in §3.8, any JavaScript value can be converted to a boolean value. The
following values convert to, and therefore work like, 
false
:
undefined
null
0
-0
NaN
""  // the empty string
All other values, including all objects (and arrays) convert to, and work like, 
true
.
false
, and the six values that convert to it, are sometimes called falsy values, and all
other values are called 
truthy
. Any time JavaScript expects a boolean value, a falsy value
works like 
false
and a truthy value works like 
true
.
As an example, suppose that the variable 
o
either holds an object or the value 
null
. You
can test explicitly to see if 
o
is non-null with an 
if
statement like this:
if (o !== null) ...
The not-equal operator 
!==
compares 
o
to 
null
and evaluates to either 
true
or 
false
.
But you can omit the comparison and instead rely on the fact that 
null
is falsy and
objects are truthy:
40 | Chapter 3: Types, Values, and Variables
Download from Wow! eBook <www.wowebook.com>
if (o) ...
In the first case, the body of the 
if
will be executed only if 
o
is not 
null
. The second
case is less strict: it will execute the body of the 
if
only if o is not 
false
or any falsy
value (such as 
null
or 
undefined
). Which 
if
statement is appropriate for your program
really depends on what values you expect to be assigned to 
o
. If you need to distinguish
null
from 
0
and 
""
, then you should use an explicit comparison.
Boolean values have a 
toString()
method that you can use to convert them to the strings
“true” or “false”, but they do not have any other useful methods. Despite the trivial
API, there are three important boolean operators.
The 
&&
operator performs the Boolean AND operation. It evaluates to a truthy value if
and only if both of its operands are truthy; it evaluates to a falsy value otherwise. The
||
operator is the Boolean OR operation: it evaluates to a truthy value if either one (or
both) of its operands is truthy and evaluates to a falsy value if both operands are falsy.
Finally, the unary 
!
operator performs the Boolean NOT operation: it evaluates to
true
if its operand is falsy and evaluates to 
false
if its operand is truthy. For example:
if ((x == 0 && y == 0) || !(z == 0)) {
// x and y are both zero or z is non-zero 
}
Full details on these operators are in §4.10.
3.4  null and undefined
null
is a language keyword that evaluates to a special value that is usually used to
indicate the absence of a value. Using the 
typeof
operator on 
null
returns the string
“object”, indicating that 
null
can be thought of as a special object value that indicates
“no object”. In practice, however, 
null
is typically regarded as the sole member of its
own type, and it can be used to indicate “no value” for numbers and strings as well as
objects. Most programming languages have an equivalent to JavaScript’s 
null
: you may
be familiar with it as 
null
or 
nil
.
JavaScript also has a second value that indicates absence of value. The undefined value
represents a deeper kind of absence. It is the value of variables that have not been
initialized and the value you get when you query the value of an object property or array
element that does not exist. The undefined value is also returned by functions that have
no return value, and the value of function parameters for which no argument is sup-
plied. 
undefined
is a predefined global variable (not a language keyword like 
null
) that
is initialized to the undefined value. In ECMAScript 3, 
undefined
is a read/write vari-
able, and  it can be  set to any  value. This error is corrected in ECMAScript 5  and
undefined
is read-only in that version of the language. If you apply the 
typeof
operator
to the undefined value, it returns “undefined”, indicating that this value is the sole
member of a special type.
3.4  null and undefined | 41
Core JavaScript
Despite these differences, 
null
and 
undefined
both indicate an absence of value and
can often be used interchangeably. The equality operator 
==
considers them to be equal.
(Use the strict equality operator 
===
to distinguish them.) Both are falsy values—they
behave like 
false
when a boolean value is required. Neither 
null
nor 
undefined
have
any properties or methods. In fact, using 
.
or 
[]
to access a property or method of these
values causes a TypeError.
You might consider 
undefined
to represent a system-level, unexpected, or error-like
absence of value and 
null
to represent program-level, normal, or expected absence of
value. If you need to assign one of these values to a variable or property or pass one of
these values to a function, 
null
is almost always the right choice.
3.5  The Global Object
The  sections above  have explained JavaScript’s  primitive types and  values.  Object
types—objects, arrays, and functions—are covered in chapters of their own later in this
book. But there is one very important object value that we must cover now. The global
object is a regular JavaScript object that serves a very important purpose: the properties
of this object are the globally defined symbols that are available to a JavaScript program.
When the JavaScript interpreter starts (or whenever a web browser loads a new page),
it creates a new global object and gives it an initial set of properties that define:
• global properties like 
undefined
Infinity
, and 
NaN
• global functions like 
isNaN()
parseInt()
(§3.8.2), and 
eval()
(§4.12).
• constructor  functions  like 
Date()
RegExp()
String()
Object()
 and 
Array()
(§3.8.2)
• global objects like Math and JSON (§6.9)
The initial properties of the global object are not reserved words, but they deserve to
be treated as if they are. §2.4.1 lists each of these properties. This chapter has already
described some of these global properties. Most of the others will be covered elsewhere
in this book. And you can look them all up by name in the core JavaScript reference
section, or look up the global object itself under the name “Global”. For client-side
JavaScript, the Window object defines other globals that you can look up in the client-
side reference section.
In top-level code—JavaScript code that is not part of a function—you can use the
JavaScript keyword 
this
to refer to the global object:
var global = this;  // Define a global variable to refer to the global object
In client-side JavaScript, the Window object serves as the global object for all JavaScript
code contained in the browser window it represents. This global Window object has a
self-referential 
window
property that can be used instead of 
this
to refer to the global
object. The Window object defines the core global properties, but it also defines quite
a few other globals that are specific to web browsers and client-side JavaScript.
42 | Chapter 3: Types, Values, and Variables
Documents you may be interested
Documents you may be interested