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



F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F

• first-child Selector: CSS Selector
The pseudo-class first-child selector applies when an element is the first child of another element. See selector patterns for formats. The subsequent siblings of the common parent will not match the first-child pseudo-class selector.

• first-letter Selector: CSS Selector
The pseudo-element first-letter selector effects the first letter of the first line of a block. Pseudo-elements inserts fictitious elements into a document's markup in order to cause special effects. The first-letter pseudo-element will cause the UA to behave as if the fictional start tag were nested inside the opening tag of the target element and after the first letter of the target elements content. See selector patterns for formats.

• first-line Selector: CSS Selector
The pseudo-element first-line selector effects the first line of a block. Pseudo-elements inserts fictitious elements into a document's markup in order to cause special effects. The first-line pseudo-element will cause the UA to behave as if the fictional start tag were nested inside the opening tag of the target element but before the target elements content. See selector patterns for formats.

• Flags: JavaScript RegExp
The grammar for specifying a regular expression can contain two parts; a pattern and an optional flag(s). The optional flag is the second argument specified in the RegExp constructor's argument list. Functionally, flags are applied to the first argument (the pattern) thereby, modifying the behavior of the matching process. Flags are called "modifiers" in some computer languages. The JavaScript regular expression flags are: global, case insensitivity and multiline mode.

• Following element: CSS 2.1 Specification
An element A is called a following element of an element B, if and only if B is a preceding element of A.

• font-family: CSS Property
The font-family property is used to specify fonts for text. The font-family property is dynamic in that it can accept more than one font as its value. The font that the designer considers the most appropriate should be specified first, since the UA will attempt a match on the initial font specified. The remaining fallback fonts are used by the browser only if the intiial font specified did not match. Values are separated by a comma to indicate that they are alternatives. Style sheet designers are encouraged to offer a generic font family as a last alternative.
font-family
Value: [ [ <family-name> | <generic-family> ] [, <family-name> | <generic-family> ]* ] | inherit
Initial: depends on user agent
Applies to: all elements
Inherited: yes
Percentages: N/A
Media: visual
Computed Value: as specified
Style Group: font
Deprecated: no
Example: code, tt { font-family: Courier, "Courier New", monospace; }


• font-size: CSS Property
The font-size property allows for the selection of alternative sizes for text. The set of property value alternatives provide for absolute values and relative values. Relative values are relative to the parent element. For absolute values, a scaling factor is used relative to the 'medium' value. Length and percentage values can not be negative.
font-size
Value: <absolute-size> | <relative-size> | <length> | <percentage> | inherit
Initial: medium
Applies to: all elements
Inherited: yes
Percentages: refers to parent element's font size
Media: visual
Computed Value: absolute length
Style Group: font
Deprecated: no
Example: h3 { font-size: medium; }


• font-style: CSS Property
The font-style property selects between normal, italic and oblique faces within a font family. Most font families do not provide separate faces for both italic and oblique. When this occurs, oblique may be substituted for 'italic' but the reverse is not allowed.
font-style
Value: normal | italic | oblique | inherit
Initial: normal
Applies to: all elements
Inherited: yes
Percentages: N/A
Media: visual
Computed Value: as specified
Style Group: font
Deprecated: no
Example: h3 { font-style: italic; }


• font-weight: CSS Property
The font-weight property selects the weight of the font for the targeted text. The values "100" to "900" form an ordered sequence, where each number indicates a weight that is at least as dark as its predecessor. The keyword "normal" is synonymous with "400", and "bold" is synonymous with "700". The "bolder" and "lighter" values select font weights that are relative to the weight inherited from the parent.
font-weight
Value: normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit
Initial: normal
Applies to: all elements
Inherited: yes
Percentages: N/A
Media: visual
Computed Value: see text
Style Group: font
Deprecated: no
Example: h3 { font-weight: 700; }


• font-variant: CSS Property
The font-variant property allows for the selection of another type of variation within a font family, that is the 'small-caps' variant. In a small-caps font, the lower case letters look similar to the uppercase ones, but in a smaller size and with slightly different proportions. Most font families do not contain a small-caps face variant, therefore, the UA must contrive the variant by applying all caps to a normal face and scaling down the size.
font-variant
Value: normal | small-caps | inherit
Initial: normal
Applies to: all elements
Inherited: yes
Percentages: N/A
Media: visual
Computed Value: as specified
Style Group: font
Deprecated: no
Example: h3 { font-variant: normal; }


• font (Shorthand Property): CSS Property
The font property is a shorthand property for setting font-style, font-variant, font-weight, font-size, line-height and font-family at the same place in the style sheet. Given a system font values or the 'inherit' value are not specified, the size and family properties are mandatory while style, variant, weight and line-height properties are optional. The system font keyword values can only be used with the font shorthand property.
font
Value: [ [ <font-style> || <font-variant> || <font-weight> ]? <font-size> [ / <line-height> ]? <font-family> ] |
caption | icon | menu | message-box | small-caption | status-bar | inherit
Initial: see individual properties
Applies to: all elements
Inherited: yes
Percentages: see individual properties
Media: visual
Computed Value: see individual properties
Style Group: font
Deprecated: no
Example:    div { font: 100% medium 'Courier New', Monaco, Monospace; }


• Font Style Group: CSS Property
The font style group is one of eleven property style groups that help define the total CSS property set. The font properties for this group are applied to text (page content) and often work in conjunction with the text style group properties. The CSS font properties have replaced the deprecated HTML font elements/attributes. The font properties that comprise this group are:

• for Statements: JavaScript Statement
The for statement is one of JavaScript's program control structures designed for repetition processing. for is a keyword in the JS language. The for statement has two main syntactical components:
  1. header: the header consists of three expressions:
    • initialization expression: The initialize expression is executed only once; on the first iteration. This expression sets the loop control counter.
    • conditional expression: The conditional expression is executed on all iterations. It is a logical expression that evaluates to a boolean value. When the conditional expression tests to be true, the loop body statements will be executed.
    • update expression: The update expression changes the value of control counter. This action should ultimately cause the test of the conditional expression to be false otherwise, the loop could be endless (an infinite loop).
  2. loop body: Following the header is a for block that is sometimes referred to as the for loop body.

The condition that will terminate the loop is tested on each iteration. As long as the test remains true, the loop is executed one more time. Once the loop condition tests to be false the loop is terminated. Once terminated, the program flow proceeds to the next sequential statement immediately after the for statement.

• for/in Statement: JavaScript Statement
The for/in statement provides the means to loop through the properties of an object. The for keyword has two uses in JS; the other and more common use is in the standard for loop. The body of the for/in statement is executed for each property of the specified object. The for/in statement uses two JS features:
  1. for: the for keyword establishes:
    • the conditional expression: the conditional expression contains:
      • loop variable: receives the property name from the in operator for each loop
      • the in operator
      • object name: the name of the object to be searched
    • the body loop statements
  2. in: the in keyword inside the conditional expression will:
    • search object: identifies all enumerable properties
    • returns property name to the loop variable


• Foreground Style Group: CSS Property
The foreground style group is one of eleven property style groups that help define the total CSS property set. The foreground property set consists of only one single property. This property is the color property. Foreground color is applied to an element's text content. When considering the color of text, we often are also concerned with the elements background. The background can have it's own color or an image. Contrasting the foreground with the background is always a main concern in Web page design.

• Formal Parameter: JavaScript OOD
This topic is being addressed relative to a OOD focus. However, the topic applies to FSD also. Formal parameters refer to the parameters of the method heading of a method definition. Formal parameters are the variables defined within the parentheses of the method heading definition. The structure (method name and actual parameters) of the invoking statement should conform to the signature of the interface mandated by the method heading and the formal parameters.

• Forward Reference: JavaScript Function
A forward reference is the ability to call a FSD before it is declare. A forward reference is not allowed in JavaScript. However, inside the same <script> tag set, a forward reference is allowed.

• Fragment Identifier: Web
A fragment identifier serves as the destination for a hyperlink reference. A section of a document can be given a named identifier. The identifier is established by specifying either the NAME attribute or the ID attribute of a document language's element. The hyperlink reference to the location in the document where the identifier is established can be either an absolute or relative reference but must end with a pound sign "#" that is immediately followed by the identifier. <a href="http://www.sitecite.com/home/topics.html#last_topic">

• Function: JavaScript Terms
A function is designed to perform a specific task. Other programming languages use synonymous terms such as: modules, subroutines and methods. Regardless of the term used, a function should be reusable, reentrant, task specific, and autonomous.
JS functions can act as:
  1. Function Statement: The function statement declaration (FSD) is top level code with global scope. The FSD is comprised of a function heading and a function body.
  2. Constructor Function: Functions can be designed to act as constructors. The behavior of the constructor function is simi liar to the OOD class constructors. These functions when used with the new operator will instantiate new objects and serve as the defining source for an object.
  3. Method: A method is a JavaScript function that is invoked through an object or a class.
    1. Class Method: Class methods are invoked through the class. There is only one copy of class methods and they have global scope.
    2. Instance Method: Instance methods are invoked through an object. All object instances of the same class type share a single copy of instance methods.
  4. Built-in Function: The methods of the Global object are actually built-in functions. These functions are directly accessible by name and have global scope.

Functions have special attributes and behavior in JavaScript:
  1. Functions are objects in JavaScript.
  2. All function objects have a an associated prototype object. The prototype object is automatically created by JavaScript for each function. The prototype object only has significance if the function is used as a constructor.
  3. All functions in JavaScript have a prototype property. The prototype property will point to the prototype object associated with the function.
  4. The function may be invoked with the parentheses operator. The invoking statement (function call statement) specifies the name of the function and supplies all required arguments within the parentheses operator.
  5. The data type of a function takes the form of a reference type.
  6. A function will return a value to the invoking statement.
  7. A function has a literal form.
  8. The term function is a keyword in JavaScript.
  9. Functions can be nested.


• Function Argument: JavaScript Function
We use the term function argument interchangeably with the term function parameter. See function parameter for details.

• Function Body: JavaScript Function
The body of a function declaration contains the JavaScript statements that perform the action that is intended for the function. With FSD definitions, the function body is enclosed by a pair of curly braces. Another term that is appropriate of the function body is the block statement.

• Function Call Statement: JavaScript Statement
Once the function has been declared, it may be invoked (or called) with the function call statement. The syntax of the function call statement as specified from left to right: first, the function name is specified, next, the actual parameters are enclosed in a set of parentheses (the parentheses operator). Each parameter in the parameter set is separated by commas.

• Function Class: JavaScript Class
The JavaScript function is supported by one of JavaScript's Native Classes, the Function class. All functions, regardless of how they are declared and named, will behave as an object of the Function class type. Using the constructor of the Function class is one (of three) way to declare a function. The remaining two ways of declaring a function are with the FSD and the function literal. See our link for class for the distinction between the terms "class" and "object".

• Function Heading: JavaScript Function
The heading of a function declaration contains the JavaScript function keyword, followed by the function name, followed by the parentheses operator that encloses the optional function parameters. The function name of the heading is used to invoke the function with a function call statement. The arguments (or parameters) of the heading are the formal parameters of the function. The parts of the function heading make up the signature of the function.

• function Keyword: JavaScript Keyword
The function keyword is JavaScript's language tool for declaring functions. Functions declared using the function keyword are named, static and must be invoked using the function call statement. A function declaration can be expressed in the form of a function literal or the function statement declaration (FSD).

• Function Literal: JavaScript Function
The declaration of a function can be expressed in the form of a literal. The function literal statement uses the function keyword and accomplishes the same thing as an FSD, with a few differing characteristics. The function literal is an unnamed expression that is typically assigned to a variable whose data is of the function type.

• Function Name: JavaScript Function
The name of a function has the same syntax limitations and requirements of any JavaScript identifier. The function name is the name used to invoke the function via a function call statement.

• Function Object: JavaScript Object
The Function object is a instance of the Function class type. A Function object can be declared and initialized by either the Function class constructor or by an Function literal statement. See our link for class for the distinction between the terms "class" and "object".

• Function Operand: JavaScript Operator
A function call operator (   ) will have a function operand on the left side of the operator. This is the name of the function and is the 1st operand of the operator.

• Function Parameter: JavaScript Function
Here, we are using the term parameter with regards to function statements. Parameters are specified in the function call statement to pass data to a named function. The data passed to a function can be in the form of expressions, literals or variables. The parameters that are specified in the FSD are called formal parameters. The parameters that are specified in the function call statement are called actual parameters. The actual parameters should have the same signature as the formal parameters. However the rules for a signature are not as strict with JavaScript as with other programming language.

• Function Return Value: JavaScript Function
A called function will return a value. The returned value can be induced by implicit or explicit means. The return statement will force a particular value to be returned to the caller. Without an explicit return statement specified in the function body, a value of undefined will be returned.

• Function Statement Declaration (FSD): JavaScript Function
A JavaScript function declaration is a definition of a deferred action. To actuate the action, you must invoke the function from event handlers or from a function call statement. The FSD consists of the function keyword, followed by the function name; next, a mandatory matching set of parentheses that may enclose optional parameter(s) that are separated by commas and finally the function body that is enclosed in a matching set of curly braces.

• Function Type: JavaScript Data Type
A function type takes the form of a reference type. This reference type points to the function object in memory. Because a function can contain an undetermined amount of JavaScript code, it's size in memory will vary. A reference to a function is accomplished with a pointer to the function object. The function object exists on the heap, while the function pointer exists on the stack.















Top            

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