WEB Developer's Glossary

Alphabetical Jump into Glossary

Symbols  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z            Back to Parent         Site Conventions         Topic Indices


• Call Object: JavaScript Function
The Call object is not a formal JavaScript object like the members of the Native Class set. The purpose of the Call object is to aid with function processing. The Call object is a temporary object that exists only while a FSD is being executed. The local variables of the executing FSD become properties of the Call object. The Call object operates in conjunction with the Global object. Recall that all global variables are properties of the Global object. The global variables of the Global object are always in the scope chain and are always visiable from anywhere in the program. The purpose of the Call object is to place local variables of the executing FSD ahead of global variables in the scope chain. In effect, they gain access priority in the scope chain. Once the FSD is done executing, the temporary local variables are removed from the scope chain and the permanent global variables move to the top of the chain. The use of an entirely different object for local variables allows JavaScript to keep local variables from overridding the global variable values when both local and global variables have the same name. Note that the FSD actual parameters as well as the local variables are also properties of the Call object.

• Caller and Callee: JavaScript Function
The Caller and Callee terms are used in reference to subroutines (or functions). Typically, the caller is in reference to the statement that is invoking a function. And the callee is in reference to the target Function Statement Declaration. The caller must understand the parameters that the callee requires and also the nature of the returned value generated by the callee. With reference to OOD terminology, the callee is comparible to the class server and the caller is an object client of the same class type requesting a service of the class.

• Canvas: CSS 2.1 Specification
For all media, the term canvas describes "the space where the formatting structure is rendered." The canvas is infinite for each dimension of the space, but rendering generally occurs within a finite region of the canvas, established by the user agent according to the target medium. For instance, user agents rendering to a screen generally impose a minimum width and choose an initial width based on the dimensions of the viewport. User agents rendering to a page generally impose width and height constraints. Aural user agents may impose limits in audio space, but not in time.

• Capturing Groups: JavaScript RegExp
Regular expression grouping patterns can be of two types: capturing and non-capturing. The capturing group will remember the characters that matched a group. Here is how this works:
  1. Your pattern contains a normal grouping (a pattern within parentheses).
  2. This group, acting as a unit, matches with a portion of the target string.
  3. This character subset of the target string is remembered.
  4. And given a reference number.
The process of capturing and remembering the group match is inefficient and unnecessary if you are not using the generated reference number later in your pattern. That being said, the use of a reference number does not trigger a rematch, but simply points to the bytes in the target string where the original match occurred.

• Cascade: CSS
The cascade refers to setting a precedence for style sheets that can originate from three separate sources. A style sheet precedence is established to help determine the appropriate style for conflicting styles. The three possible sources for style sheets are: user agent, user and author. The precedence of style sheets follow this order:
  • The lowest precedence (weakest) is the user agent style sheet.
  • The user-defined style sheet takes higher precedence that the user agent style sheet.
  • The author's style sheet is the strongest. It takes precedence over the user-defined and user agent style sheets.

• Case Insensitive Flag: JavaScript RegExp
The optional case insensitive flag is one of three flags (or modifiers) provided with JavaScript regular expressions. The case insensitive flag forces the regular expression processor to match regular expression patterns to target string regardless of case.

• Case Sensitive: JavaScript Syntax
Uppercase and lowercase letters are handled as different characters. JS identifiers are case sensitive.

• Character Class: JavaScript RegExp
A character class is specified by enclosing a group of characters in square brackets. The [ ] symbols indicate to the regular expression processor to match any one character in the group character set to the target string. The matching process abates once a single match occurs. A character class's potential character set may be comprised of any of the regular expression literal characters. Two additional meta characters (the range class and negation class characters) are allowed to coexist inside the brackets with the class characters. These meta characters are not to be considered part of the character set of the character class.

• Character Set: JavaScript
The EMCA-262 standard supports the Unicode character set. Unicode is a 16-bit encoding scheme that has a total of 65,536 characters. The Unicode encoding can represent virtually all written languages. Antiquated internet browsers and operating systems can be a consideration and may not support the 16-bit Unicode encoding scheme. Note that ASCII and Latin-1 (ISO-8859-1) are both incorporated into Unicode and these character sets are adequate for 99% of most English based Web pages.

• Child: CSS 2.1 Specification
An element A is called the child of element B if and only if B is the parent of A.

• Child Selector: CSS Selector
The child selector matches when an element is a child of another element. The child selector is one of three relational selectors. The three relational selectors (descendant, child and sibling) all require a combinator. The combinator serves as a pattern separator and also determines the relationship of the elements in the pattern. The combinator for the child selector is the ">". The ">" combinator can be translated as: "is a child of" when reading from right to left in the pattern. See selector patterns for formats.

• Class: JavaScript OOD
Most commentary concerning the JavaScript Native Classes will use the term "class" in reference to the native set of objects. For our purposes, we use the term "class" in favor of the term "object" to describe the Native Class set. We prefer to use the term "object" when referring to the object that has been instantiated from a Native Class type.

Given our usage of the term class, a JavaScript Native class will exhibit the following qualities and behavior:

  • class defines an object: JS Native classes are used to create (instantiate) an object of the class type. The class is the defining construct. The resulting object acquires the nature and behavior of the defining class.
  • encapsulation: Encapsulation wraps properties and operations together into a single unit (object). This object understands how to interface with other objects but does not know the implementation of the other object.
  • members: JS uses the term property to refer to members of an object of a class type.
  • instantiate: Object instances are the result of instantiation. Instantiation requires using the new operator with a class constructor as it's constructor operand.
  • multiple instances of a class: There may be many instances of a class in JavaScript.
  • inheritance: JavaScript supports prototype-based inheritance. An instance of a class type inherits members of the protoype object.
  • constructors: All Native class types have a constructor for creating objects of the class type. User defined classes also need a constructor method.
  • access specifiers: Class access specifiers (private, protected, public, static) are reserved keywords for possible ECMA-262 extensions. They are not currently incorporated into core JS.
  • pre-defined class: The Native Classes of core JS are pre-defined classes. Be aware, that the Java pre-define class libraries dwarf the twenty or so Native classes of JavaScript.
  • user defined class: JS allows you to build custom classes (user defined classes).
  • super class and subclass: Most Native classes behave as a subclass. However, the Object class acts as a super class. And the Error class behaves both as a super class and as a subclass.

• Class Method: JavaScript OOD
A class method is a method of a class. Class methods are created and initialized by setting a class property to a function value. Class methods belong to the Global object making them accessible from anywhere. Only one copy of the class method exists at any given time. You should not use the this keyword within a class method since class methods are not invoked through an object. You invoke a class method using the constructor name (same as class name) followed by the property name (points to a function) separated by a period. With OOD terminology, class methods are also called static methods.

• Class Property: JavaScript OOD
A class property is a data value of a class. Class properties are created and initialized in the class constructor. The invoking statement for the class property will prefix the class name to the property separated by a period. Each object that is instantiated from a class type will share the class property(s). There is never more than one copy of a class property in memory. With OOD terminology, class properties are also called static properties. A class property is invoked through the class.

• Class Selector: CSS Selector
The class selector will match all elements of the document tree whose class attribute is set to the class name provided in the selector. Sections of a document that can share the same styles can be given a common class name (name given in the class attribute). See selector patterns for format.

• Client/Server: JavaScript OOD
The server is analogous to the class. Likewise, the client is analogous to an object instance of the class type. The class serves all clients requesting use of it's methods.

• Client-side Image Map: Web
An image map will contain numerous "hotspots" that will provide a different URI being loaded when the user clicks on the "hotspot". Each hotspot has its own designated URI. Web designers have two methods for setting up an image map: client-side image maps and server-side image maps. The primary use of image maps is to assist with site navigation.

• Color on the Web: Web
There two methods of rendering color on the Web. One is the RGB (Red, Green, Blue) triplet. And the second is with named colors. The RGB color triplet numbers that make up the value for HTML color attributes are represented with hexadecimal numbers. However, with CSS, there are three scales (or methods) to render color.

• Colors, Named: Web
There are approximately 140 colors that have a color name. Different browsers may render the named colors differently. It is safer to use the Hex RGB triplet number rather than the color name. Named colors are not the same as safe colors.

• Colors, Safe: Web
There are 216 RGB hex triplets that are browser safe. The hex triplet for safe colors are confined to six values per primary color. Each member of the triplet can contain one value from the following set of six numbers: 00, 33, 66, 99, CC and FF. The combinations of the six hex numbers for the three primary colors is: (6X6X6) = 216 colors.

• color: CSS Property
The CSS color property determines the color of an element's text. Values for CSS color related properties are all expressed using the CSS <color> data type. There are two primary methods of representing color with the CSS <color> data type: 1) the RGB color model and 2) using color keywords.
Value: <color> | inherit
Initial: depends on user agent
Applies to: all elements
Inherited: yes
Percentages: N/A
Media: visual
Computed Value: as specified
Style Group: Foreground
Deprecated: no
Example: p { color: #cdf0ff; } /*a hex color code as a RGB triplet*/
p { color: gray; } /*using a color keyword*/

• Combinator: CSS 2.1 Specification
A selector is a chain of one or more simple selectors separated by combinators. The combinator determine the relationship between the two simple selectors. This relationship is based on the document tree. The complete set of all CSS selectors contains three selector types that use combinators. These three selectors and the associated combinator follow:
  • descendant selector: the combinator is the space; the pattern is: E F
  • child selector: the combinator is the ">"; the pattern is: E > F
  • sibling (or adjacent) selector: the combinator is the "+"; the pattern is: E + F

• Comma Operator: JavaScript Operator
The comma operator ( symbol: , ) allows execution of more than one operation in a single statement. It is used mainly to declare multiple variables within one single statement. This operator is also used in complex "for" loop statements. The usage of commas in function calls to separate parameter is not a use of the comma operator.
The attributes of this operator are:

• Comment Statement: JavaScript Syntax
ECMAScript has two types of comment lines. The single-line comment begins with to forward slashes (//). The multiline comment begins with a forward slash and an asterisk (/*) and ends with with an asterisk and a forward slash (*/). Comments are treated like white space.

• Comments, CSS: CSS Structure
The CSS comment has but one format. A CSS comment begins with a forward slash and an asterisk (/*) and ends with an asterisk and forwad slash (*/). Everything between the starting point and ending point is treated as white space, that is, the interpreter skips over all commented text. The purpose of coding comments in any language is to document the code. Although CSS has but one format for comments, comments can appear in many scenarios:
  • Single line comments: /*a comment can appear on a line all by itself*/ hr { color: #000080; }
  • Multiline comments: /*comments can span over many lines all text between the beginning and ending comment tokens will be treated as white space*/ hr { color: #000080; }
  • Inside a rule: hr { /*a comment inside a rule*/ color: #000080; }
  • Same line as declaration: hr { color: #000080; }/*blue*/
  • Inside a declaration: hr { color: /*blue*/ #000080; }

• Complex Expression: JavaScript Expressions
Complex expressions are one or more simple expressions combined with one or more operators. The combined expression will reduce to a single value. Core JS statements are not considered expressions. The hybrid expression statement are both statements and expressions because they are a stand alone executable statement but also include an operator. The hybrid expression statement may include a complex expression but the terms are not synonymous. The complex expression in of itself does not make a complete statement. It typically occupies the right hand side operand of the associated operation.

• Composite Data Type: JavaScript Data Type
JavaScript supports three composite types: Object, Array and Function. We use the term composite data types interchangeably with the term reference types. Composite types can represent a collection of values that can hold any of the primitive types plus other data. Unlike primitive types, the composite types have inconsistent storage size characteristics. An object can have any length with any number of methods and properties. An array can have any number of elements and a Function can contain any amount of JavaScript code. Composite types require extra memory management because of there varying size. The composite data types each have a unique literal syntax that aids the JS interpreter to dynamically type a given variable appropriately.

• Compound Assignment Operators: JavaScript Operator
The compound assignment operator is used to assign a value to a variable, plus perform an operation. The operation can be one of the arithmetic operations, bitwise shift operations or bitwise logical operations. The assignment operator expects its lefthand operand to be a variable, an element, or a property ( lvalue ). The righthand operand can be a value of any type. The value on the right is assigned to the lvalue on the left after the operation is performed. The compound assignment operator symbol is a combination of the assignment symbol ( = ) and the symbol for the add on operation.
The attributes of this operator are:

• Compound Statement: JavaScript Statement
The compound statement will contain more than one statement much like the block statement.

• Computed Value CSS Property Values
The computed value is an intermediate value that the UA will arrive at in a four step process during the property value assignment task. The four step value assignment process is:
  1. resolve the specified value,
  2. resolve the computed value from the specified value,
  3. resolve the used value from the computed value,
  4. resolve the actual value from the used value.

A computed value is resolved from the specified value. Arriving at an computed value may or may not require a computation. A specified value that is already an absolute value will not require a computation. However, relative values always require a computation.

• Conditional Operator: JavaScript Operator
JavaScript has a conditional operator ( symbol: ? : ) that takes three operands. The first operand ( left of the ? ) contains a condition. The operator evaluates the condition to a boolean value. The second and third operands are separated by the colon. If the condition of the first operand evaluates to true, then the operator returns the value of the second operand. If the condition of the first operand evaluates to false, then the the operator returns the value of the third operand. This behavior achieves the equilvalent of the if/else statement. This operator is typically used in conjunction with an assignment operator to assign the variable (left operand of assignment operation) one of the values from either of the 2nd or 3rd operands based on the conditional expression.
The attributes of this operator are:

• Constant: JavaScript Statement
Constants are like variables, however, a constant's value can not be changed or altered. JS has many built-in constants, such as with the Number type. The constant statement is not official ECMA-262. However, the "const" reserved word is recognized by ECMA-262 and most modern browsers will render these statements.

• Constructor: JavaScript Class
A constructor is a Function that instantiates and initializes objects. Each constructor has an associated prototype object that is used to implement inheritance and shared properties. All JS Native Classes have an associated constructor. The constructors of the Native Classes are actually properties of the Global object. Being properties of the Global object allows Native Class constructors to be accessed from anywhere in JS program.

• Constructor Operand: JavaScript Operator
The constructor operand is the name of a constructor function. The constructor operand can be a native class constructor function: "String, Date, Array, etc." or a user defined class constructor function. Recall that the name of a JS class is one and the same as the name of the class constructor.

• Content: CSS 2.1 Specification
The content associated with an element in the source document. Some elements have no content, in which case they are called empty. The content of an element may include text, and it may include a number of sub-elements, in which case the element is called the parent of those sub-elements.

• content Property: CSS Property
The content property is used with the :before and :after pseudo-elements to generate content in a document. This property will render counters in conjunction with the counter-increment and counter-reset properties. In addition, the 'content' property will insert quotation marks into content as prescribed with the quotes property. The 'content' property will also allow strings, URIs and attribute markup to be inserted into actual content.
Value: normal | none | [ <string> | <uri> | <counter> | attr(<identifier>) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
Initial: normal
Applies to: :before and :after pseudo-elements
Inherited: no
Percentages: N/A
Media: all
Computed Value: On elements, always computes to 'normal'. On :before and :after, if 'normal' is specified, computes to 'none'. Otherwise, for URI values, the absolute URI; for attr() values, the resulting string; for other keywords, as specified.
Style Group: Generated Content
Deprecated: no
Example: h2.toc:before { content: "Chapter: "; }/*insert the string 'Chapter' before h2 headings*/

• continue Statement: JavaScript Term
The continue statement allows for premature exiting from a loop. The continue statement instructs the interpreter to exit the body of the control structure and proceed with the next iteration. The continue statement can only be used inside a repetition control structure (while, do/while, for, for/in). The syntax of the continue statement includes the optional label identifier.

• Continuous Media Group: CSS Property
The continuous media group represents those CSS properties that are normally associated with the screen user interface, but the continuous media group is also appropriate for all of the following media types: braille, handheld, screen, speech, tty and tv. The continuous media group along with the paged media group represent the user interface media group options. Also see CSS Media Group.

• counter-increment Property: CSS Property
The counter-increment property supports CSS automatic numbering capabilities. The property accepts one or more names of counters, each one optionally followed by an integer. The integer indicates by how much the counter is incremented for every occurrence of the element. The default increment is 1. Automatic numbering in CSS 2.1 is controlled with two properties, 'counter-increment' and 'counter-reset'. The counters defined by these properties are used with the counter() and counters() functions of the the content property.
Value: [ <identifier> <integer>? ]+ | none | inherit
Initial: none
Applies to: all elements
Inherited: no
Percentages: N/A
Media: all
Computed Value: as specified
Style Group: Generated Content
Deprecated: no
Example: div { counter-increment: section, 5; }/*the counter 'section' will be incremented by 5*/

• counter-reset Property: CSS Property
The counter-reset property supports CSS automatic numbering capabilities. The property accepts one or more names of counters, each one optionally followed by an integer. The integer indicates the value to which the counter will be reset. The default reset value is 1. Automatic numbering in CSS 2.1 is controlled with two properties, 'counter-increment' and 'counter-reset'. The counters defined by these properties are used with the counter() and counters() functions of the the content property.
Value: [ <identifier> <integer>? ]+ | none | inherit
Initial: none
Applies to: all elements
Inherited: no
Percentages: N/A
Media: all
Computed Value: as specified
Style Group: Generated Content
Deprecated: no
Example: div { counter-reset: section, 0; }/*the counter 'section' is set to zero*/

• CSS (Cascading Style Sheets): CSS
CSS is a style sheet language that allows authors and users to attach style (e.g., fonts and spacing) to structured documents (e.g., HTML documents and XML applications). CSS simplifies Web authoring and site maintenance by separating the presentation style of documents from the content of documents.

• Current Time: JavaScript Date & Time
In computer jargon, this is the date and time currently registered in the computer clock. Most of us are working on a client machine that is running many applications. The applications that run on the client (like your browser) will reflect the clients clock time. However, your client may interface to applications that are running on the server or mainframe. These applications may reflect the date and time from the server or mainframe clock.


Rx4AJAX        About Us | CSS Index | JS Index | HTML Index | Contact Us | Privacy Policy | Built By PPThompson: 2008