his chapter discusses values that JavaScript recognizes and describes the
fundamental building blocks of JavaScript expressions: variables and
literals.
JavaScript recognizes the following types of values:
-
-
Numbers, such as 42 or 3.14159
-
Logical (Boolean) values, either true or false
-
Strings, such as "Howdy!"
-
null, a special keyword denoting a null value
This relatively small set of types of values, or data
types, enables you to perform useful functions with your applications.
There is no explicit distinction between integer and real-valued numbers.
Nor is there an explicit date data type in Navigator. However, you can use
the Date object and its methods to handle dates.
Objects and functions are the other fundamental elements
in the language. You can think of objects as named containers for values,
and functions as procedures that your application can perform.
JavaScript is a loosely typed language. That means you
do not have to specify the data type of a variable when you declare it, and
data types are converted automatically as needed during script execution.
So, for example, you could define a variable as follows:
var answer = 42
And later, you could assign the same variable a string
value, for example,
answer = "Thanks for all the fish..."
Because JavaScript is loosely typed, this assignment does
not cause an error message.
In expressions involving numeric
and string values, JavaScript converts the numeric values to strings. For
example, consider the following statements:
x = "The answer is " + 42
y = 42 + " is the answer."
The first statement returns the string "The answer is
42." The second statement returns the string "42 is the answer."
For more information on these functions, see
Chapter 9, "Built-in objects and
functions."
JavaScript provides several special functions for manipulating
string and numeric values:
-
-
eval attempts to evaluate a string
representing any JavaScript literals or variables, converting it to a number.
-
parseInt converts a string to an
integer of the specified radix (base), if possible.
-
parseFloat converts a string to a
floating-point number, if possible.
You use variables as symbolic names for values in your
application. You give variables names by which you refer to them and which
must conform to certain rules.
A JavaScript identifier, or
name, must start with a letter or underscore ("_"); subsequent characters
can also be digits (0-9). Because JavaScript is case sensitive, letters include
the characters "A" through "Z" (uppercase) and the characters "a" through
"z" (lowercase).
Some examples of legal names are Number_hits,
temp99, and _name.
You can declare a variable in two ways:
-
-
By simply assigning it a value; for example,
x = 42
-
With the keyword var; for example,
var x = 42
When you set a variable identifier by assignment outside
of a function, it is called a global variable, because it is available
everywhere in the current document. When you declare a variable within a
function, it is called a local variable, because it is available only
within the function. Using var is optional, but you need to use it
if you want to declare a local variable inside a function that has already
been declared as a global variable.
For information on using variables across frames and windows,
see Chapter 3, "Using windows and
frames."
You can access global variables declared in one window
or frame from another window or frame by specifying the window or frame name.
For example, if a variable called phoneNumber is declared in a FRAMESET
document, you can refer to this variable from a child frame as
parent.phoneNumber.
You use literals to represent values in JavaScript. These
are fixed values, not variables, that you literally provide in your
script.
Integers can be expressed in decimal (base 10), hexadecimal
(base 16), and octal (base 8). A decimal integer literal consists of a sequence
of digits without a leading 0 (zero). A leading 0 (zero) on an integer literal
indicates it is in octal; a leading 0x (or 0X) indicates hexadecimal. Hexadecimal
integers can include digits (0-9) and the letters a-f and A-F. Octal integers
can include only the digits 0-7.
Some examples of integer literals
are: 42 0xFFF, and -345.
A floating-point literal can have the following parts:
a decimal integer, a decimal point ("."), a fraction (another decimal number),
an exponent, and a type suffix. The exponent part is an "e" or "E" followed
by an integer, which can be signed (preceded by "+" or "-"). A floating-point
literal must have at least one digit, plus either a decimal point or "e"
(or "E").
Some examples of floating-point
literals are 3.1415, -3.1E12, .1e12, and 2E-12
The Boolean type has two literal values: true and
false.
A string literal is zero or more characters enclosed in
double (") or single (') quotation marks. A string must be delimited
by quotation marks of the same type; that is, either both single quotation
marks or double quotation marks. The following are examples of string
literals:
-
-
"blah"
-
'blah'
-
"1234"
-
"one line \n another line"
In addition to ordinary characters, you can also include
special characters in strings, as shown in the last element in the preceding
list. The following table lists the special characters that you can use in
JavaScript strings.
For characters not listed in the preceding table, a preceding
backslash is ignored, with the exception of a quotation mark and the backslash
character itself.
You can insert quotation marks
inside strings by preceding them with a backslash. This is known as
escaping the quotation marks. For example,
var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service."
document.write(quote)
The result of this would be
He
read "The Cremation of Sam McGee" by R.W. Service.
To include a literal backslash
inside a string, you must escape the backslash character. For example, to
assign the file path c:\temp to a string, use the following:
var home = "c:\\temp"