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



S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S

• Scheme: WEB URL HTTP
The term scheme as used here pertains to internet protocols established for URLs and URIs. For example, the scheme for the HTTP URL protocol is "http://". The W3C maintains a list of URI schemes at: http://www.w3.org/Addressing/schemes.html. This listing effort has been retired, but you can get a feel for the URI scheme set. Also, the IANA maintains a list of URL schemes at: www.iana.org/assignments/uri-schemes. Each scheme entry has the appropriate RFC reference provided.

• Scope: JavaScript Term
The term scope pertains to variables. The scope of a variable is the region of your program in which the variable is visible. A variable of global scope is visible for all regions of your program. A variable with local scope is visible for the region inside the function of which the variable was declared.

• Scope Chain: JavaScript Term
The scope chain is a JS process used to establish variable name resolution. The scope chain is a chain of objects. There are two types of objects that can exist on the chain. First, the Global object always exists on the chain. In addition to the Global object, there may be one or more Call objects. A Call objects existence on the chain is temporary. Each Call object represents a function that has been invoked (called) and is currently active (executing). Once the function terminates execution, it's Call object vanishes from the scope chain. With nested functions, we can have multiple Call objects on the scope chain. To administer variable name resolution, the scope chain adheres to a precedence hierarchical scheme. The first object in the chain that resolves the variable will be the variable's value. A chain can fall into one of three states:
  1. Top Level Only: When there are no active functions executing, then only the variables from the Global object are on the scope chain. These variables may be from top level code or other built-in variables belonging to the Global object. All variables are looked up from this object. It is a chain of one object only.
  2. Function - Not Nested: An executing function will add it's Call object to the scope chain. Now we have a chain of two objects. The first level is the function's Call object. The second level is the Global object. Variables are looked up first to the function's Call object and when not found there, then resolution is attempted at the Global object.
  3. Nested Functions: With nested functions we have three or more objects in the chain. The variable resolution process starts from the inner most function call and continues outward through all function Call objects until the ever present Global object is reached.


• Selector: CSS Selector
A selector and the property declaration serve as the two basic parts to a CSS rule. The selector tells the UA what to format, where the property declaration tells the browser how to format. The selector specifies what elements in the document tree should receive the style rule. It performs this through a process of matching the selector pattern to the elements in the tree. There are numerous types of selectors where each type has a preset pattern. These patterns specify the type of selector via special syntax and keywords. The following list provides the complete set of selector types and links to it's definition:


• Selector Patterns: CSS Selector
All CSS selector type variations have a unique selector pattern. The following table provides the pattern appropriate for each selector type:

Patterns of CSS Selectors
Selector Name Pattern Matching
Footnotes         Pattern Notations:
E and F represent elements where,
E - the initial element of a pattern and
F - a subsequent element in the pattern and related to E in the document tree
#myid - an identifier given to an attribute ID
.classname - an identifier given to class attribute(s)
E:pseudo-class - the notation for representing a pseudo-class
E:pseudo-element - the notation for representing a pseudo-element
(c) - a language code for the lang pseudo-class
att - placeholder for attribute name; used in the attribute pseudo-class selectors
val - placeholder for an attribute value; used in the attribute pseudo-class selectors
E F - indicates a ancestor/descendant relationship; F being the descendant
E > F - indicates a parent/child relationship; F being the child
E + F - notation that indicates a sibling relationship
universal selector * matches any element; asterisk acts as a wildcard
type selector E matches any element of type E
ID selector E#myid matches any E element with ID equal to "myid"
class selector E.classname matches all E elements whose class attribute is set to classname
pseudo-class selectors E:first-child (see first-child selector) matches element E when E is the first child of its parent
E:link
E:visited
(see link selectors) matches element E if E is the source anchor of a hyperlink of which the target is not yet visited (:link) or already visited (:visited)
E:active
E:hover
E:focus
(see dynamic selectors) matches E during certain user actions
E:lang(c) (see language selector) matches element of type E if it is in (human) language c
pseudo-element selectors E:first-line matches element E,s first line
E:first-letter matches element E,s first letter of first line
E:before matches element E and inserts generated content before E's content
E:after matches element E and inserts generated content after E's content
attribute selectors E[att] (see simple attribute selector)
matches any E element with the "att" attribute (the value of att is not important)
E[att=val] (see attribute value selector)
matches any E element whose "att" attribute value is equal to "val"
E[att~=val] (see attribute space-separated list selector)
matches any E element whose "att" attribute value is a list of space-separated values, one of which is equal to "val"
E[att|=val] (see attribute hyphen-separated list selector)
matches any E element whose "att" attribute value is a list of hyphen-separated values, one of which is equal to "val"
descendant selector E F matches any F element that is a descendant of an E element
child selector E > F matches any F element that is a child of an E element
sibling selector E + F matches any F element immediately preceded by a sibling element E


• SGML: Web
Standard Generalized Markup Language: SGML is a system for defining markup languages. The precursor to SGML was GML that was originated at IBM in the 1960's. The ISO (International Organization for Standards) developed the standard version of SGML in 1986.

• Shorthand Mechanism: CSS Rules
CSS has several shorthand mechanisms that compact and simplify CSS style sheets. These mechanisms are:
  • Grouping Selectors: a comma separated group of selectors that all share the same property declaration.
  • Shorthand Property: a single property that represents many properties.
  • Grouping Declarations: multiple property declarations can be specified in a semicolon separated group and is called a declaration block.


• Shorthand Property: CSS Property
Some CSS properties are special because they allow an author to specify the values of many properties with just one single property. These special properties are called shorthand properties. When values are omitted from a property declaration taking the shorthand form, the associated property for the missing value will be assigned its initial value. Following is the complete set of shorthand properties: background, border, border_bottom, border_top, border_left, border_right, border_color, border_style, border_width, font, list_style, margin, outline and padding.

• Sibling: CSS 2.1 Specification
An element A is called a sibling of an element B, if and only if B and A share the same parent element. Element A is a preceding sibling if it comes before B in the document tree. Element B is a following sibling if it comes after A in the document tree.

• Sibling (Adjacent) Selector: CSS Selector
A sibling selector's pattern is made up of two or more selectors separated by a plus sign. The sibling is also referred to as the adjacent selector and 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 sibling selector is the "+" sign. See selector patterns for formats.

• Side Effect: JavaScript Term
A side effect pertains to an event that causes data to be altered. Many operators will cause side effects (alter the value of an operand). Other operators will return a value. Operators that cause side effects are: pre increamental and decremental operators, post increamental and decremental operators, bitwise shift operators, assignment operators, void operator and parentheses operator.

• Signature: JavaScript OOD
When invoking a method or function, the matching of actual parameter to formal parameters is based on the signature. The signature is a also used in conjunction with overriding methods. Traditionally, with strictly typed languages, the signature involved an exact match on:
  1. the method name
  2. the number of parameters
  3. the data type of the parameters
  4. the order of parameters in the methods parameter list
However, with JavaScript the strict adherence to an exact match only applies to the method name. The other criteria is compromised due to:
  • the number of parameters: JavaScript will ignore actual parameters whose numbers are greater than the expected formal parameter set. Also, when the actual parameter set is less than the expected formal parameter set, the unmatched formal parameters will be assigned the undefined value.
  • the data type of the parameters: the data types of the actual and formal parameters are not checked (this is because JavaScript is a weakly typed language).
  • the order of parameters: because of 2 and 3 above, the order of parameters can not be checked.


• Simple Assignment Operator: JavaScript Operator
The simple assignment operator ( symbol: = ) is used to assign a value to a variable. 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.
The attributes of this operator are:

• Simple Character Class JavaScript RegExp
The simple character class is designated with square brackets. The simple character class is one of many character classes. It is called "simple" because it does not contain additional meta charactes such as the range, negation and other more complex charater classes. The characters that are within the character class brackets will be included in the regexp matching pattern. This character set is combined with additional regular expression literal characters to form the complete matching pattern.

• Simple Expression: JavaScript Expression
The term simple expression pertains to a single token that can be reduced to a single value. The most common tokens that fit this criteria are literals, identifiers and a few keywords.

• Simple Selector: CSS Selector
A simple selector is a selector that is not dependant on additional relationships of the document tree. They are simple

• Source Document: CSS 2.1 Specification
The source document is the document to which one or more style sheets apply. This is encoded in some language that represents the document as a tree of elements. Each element consists of a name that identifies the type of element, optionally a number of attributes, and a (possibly empty) content. For example, the source document could be an XML or SGML instance.

• Specificity: CSS Selector
The specificity of a selector is determined by a predefined priority ranking scheme. When an element has two or more conflicting property style declarations because of multiple applicable selectors, the style with the highest specificity will be the elected candidate. Inline styles have the highest specificity rank. Four numbers (a,b,c,d) are calculated based on levels of selector complexity, then these four numbers are concatenated (not added) to arrive at a single value and the selctor with the highest resulting number will be the rule that is applied to the targeted markup. Conflicting property style declarations are influenced by: the cascade, multiple style source (browser, user, author), inheritance and native markup (for example, the 'style' attribute for HTML elements).

• Specified Value CSS Property Values
The specified value is the initial value resolved during the property value assignment process. The specified value is resolved in a specific order as indicated from the options below:
The specified value is the first step of a four step property value assignment process:
  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.


• Standard: ECMA-262: Standard
In 1997, JavaScript 1.1 was submitted to the European Computer Manufactures Association (ECMA) as a proposal for standardization. From this effort by the ECMA came ECMA-262, a standard defining the ECMAScript scripting language. ECMA-262 standardized the syntax and semantics of a cross-platform, vendor neutral scripting language. ECMAScript has also been adopted by the ISO/IEC as a standard (ISO/IEC-16262). The core portion of JavaScript is based on ECMAScript. However, it is generally agreed that JavaScript also includes the DOM and BOM technologies.

• Standard: IEEE 754 Standard
The ECMA-262 standard comply's with the IEEE 754 standard. This standard allows for 64-bit (8-bytes) double-precision values with up to 17 decimal places. Values are truncated after 17 decimal points which can lead to mathematical errors for extreme precision math.

• Statement: JavaScript Core
Statements cause something in the program environment to change. The change can be to program flow, variables, objects or the user environment. A program is made up of a series of statements. A statement will have internal components (eg, expressions, blocks, keywords, identifiers).

• String: JavaScript Term
A string is a series of characters encoded in single or double quotes. The ECMA-262 standard mandates support of the Unicode character set. JS supports string data with the String class. The string data type is also supported and incorporated into the JS language. Strings defined with a string literal will acquire the nature and behavior of a string object; they have the quality of a wrapper class. Interpreter rules for handling white space are different for strings. Also, some non-typical characters must be escaped.

• String Class: JavaScript Class
The String class is a JS Native Class that supports the JS String data type. Object instances of the String class type have access to the properties and methods of the String class. Variables with the String data type adopt the nature and behavior of a String object. See our link for class for the distinction between the terms "class" and "object".

• String Literal: JavaScript Literal
A String literal is zero or more characters enclosed in single or double quotes. Each character may be represented by an escape sequence. String literals are of the string type. A string literal with two or more consecutive spaces will not be treated as white space.

• String Object: JavaScript Object
A String object is a member of the type Object. It is an instance of the built-in String object (class). That is, a String object is created by using the String constructor in a new expression, supplying a string as an argument. The resulting object has an implicit property that is the string. Strings created with a string literal will adopt the qualities of a String object; the string literal acquires the nature of a wrapper class.

• String Operand: JavaScript Operator
The string operand contain a value that evaluates to the type String. When the string operand is used with the binary addition operator, the operation performed is that of concatenation. The string operand can also be used with the greater than and less than operators.

• String Type: JavaScript Data Type
A type String is a set of all string values.

• String Value: JavaScript Value
A string value is a member of the type String and is a finite ordered sequence of zero or more 16-bit unsigned integer values. That is, the 16-bit Unicode character set.

• Structured Programming: JavaScript Term
Structured programming is a programming paradigm where program design is limited to: 1) sequential statements, looping statements, conditional statements and subroutines. Structured programming is known for a top-down design. Subroutines are advantageous in that code is centralized and reusable. Our JavaScript functions are a form of subroutines. Note that structured programming is radically different from object orient programming. The later programming style is more prevalent in modern program languages (Java, C++) and structured programming is common in the older languages (Cobol, Fortran). Most modern languages support both styles.

• Style Sheet: CSS 2.1 Specification
Style sheets are a set of statements that specify presentation of a document. Style sheets may have three different origins: author, user, and user agent.

• Style Sheet Compatibility: CSS Rule
CSS Style sheets typically have backwards compatibility from CSS version to version. The same is true for forward compatibilty. Here are the exceptions:
  • CSS 1 style sheets are generally compatible with CSS 2.1; however, there are some semantic changes with CSS 2.1 that are different than CSS 1.
  • CSS 2.0 style sheets may experience problems with CSS 2.1, since CSS 2.1 has deprecated some of CSS 2.0 features.
  • CSS 2.1 style sheets are backward compatible with previous version. Of course features new to CSS 2.1 will not render appropriately under a previous version.


• Subclass: JavaScript OOD
The Native classes of core JavaScript are built on an inheritance hierarchy. The Object class is the super class at the top of this hierarchy. All other Native classes behave as a subclass and inherit from the Object class. The Error class acts as both a subclass and a super class. The Error class inherits from the Object class and in turn the error subclasses (TypeError, SyntaxError, RangeError, etc.) inherit from the Error class.

• Subtraction Operator: JavaScript Operator
The subtraction operator ( symbol: - ) will subtract the second operand from the first operand. Non-numeric values in either operand will give a result of NaN. Special rules apply to NaN numbers and Infinity numbers.
The attributes of this operator are:

• Super Class: JavaScript OOD
JavaScript objects of the Native classes can inherit properties from a super class. The Object class acts as a super class to all other Native classes. All other Native classes behave as a subclass.

• switch/case/default Statements: JavaScript Term
The switch/case/default statements are three separate JS features that work together to exercise selection of program control options. A typical switch statement contains the switch and case keywords and the optional default keyword, plus break statements. The switch statement provides the means for constructing multiple branching conditions. The switch statement contains an expression that is evaluated in the case clause. When the value of the expression matches the case value, the case statements execute until a break statement is found or until the end of the switch structure is reached. When the value of the expression does not match any of the case values, the statements following the default clause will execute.

• Syntax, CSS: CSS Specification
As with most computer related languages, CSS as a specific and predefined syntax and grammar. The UA must have precise rules when tokenizing raw script. The tokenizing process is too involved for our purposes but we have presented the syntax highlights of each level of the CSS hierarchical rule structure:
  • statement: ruleset | at-rule;
  • at-rule: @keyword;
  • ruleset: selector { declaration [; declaration ]* };
    curly braces encompass the declaration with multiple declarations separated by semicolons
  • selector: any;
    any type of selector
  • selector grouping: any, [ any ]*;
    any selector, commas will group multiple selectors
  • declaration block: { declaration [; declaration ]* };
  • declaration: { property: value };
    a property name followed by a colon followed by a value
  • property: any
    any property name
  • value: any [ any ]+;
    any valid value for related property; a shorthand property may have many values separated with spaces

The simple grammar used above is:
  • * : zero or more
  • + : one or more
  • ? : zero or one
  • | : separates alternatives
  • [ ] : grouping


• Syntax, JavaScript: Core ECMAScript
Core ECMAScript dictates the syntax for JavaScript. The key features of ECMAScript syntax: everything is case-sensitive, variables are weakly typed, the end-of-line semicolon is optional, braces designate block statements and comments are the same as Java and C.

• SyntaxError Subclass: JavaScript Class
The JS interpreter can throw an instance of the SyntaxError subclass when certain functions; RegExp(), Function(), eval(), experience syntax errors. The JavaScript programmer can also create SyntaxError instances with the SyntaxError class constructor for the purpose of capturing the run-time exceptions. The SyntaxError subclass inherits from the Error class that acts as a super class. The complete set of error subclasses are: EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError.

• System Colors: CSS 2.1 Specification
The system color keyword values are an additional source for CSS color. They are a set of 28 color keyword names that represent various aspects of the user interface. System colors will be deprecated with CSS 3.0.

• System Fonts: CSS 2.1 Specification
The system fonts keyword values can only be used with the font shorthand property and can be handy when the goal of your web application is to memic the look and feel of the user's OS environment. The system font sets all other aspects of the font (weight, size, style, etc.). The keywords that CSS recognizes as system fonts are: caption, icon, menu, message-box, small-caption, status-bar.















Top            

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