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



R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R

• Range Class JavaScript RegExp
When the character class contains the hyphen (-) sign, the characters on each side of the hyphen indicate the upper and lower range limit. And all characters between the upper and lower limits are also included in the regular expression pattern.

• RangeError Subclass: JavaScript Class
The JS interpreter can throw an instance of the RangeError subclass when a numeric value is not in its valid range. The JavaScript programmer can also create RangeError instances with the RangeError class constructor for the purpose of capturing the run-time exceptions. The RangeError 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.

• Recursion: JavaScript Term
Recursion applies to a program control structure that facilitates repetition. The repetition is accomplished with a function that calls itself. The body of the recursive function contains a statement that invokes another copy of itself. These successive recursive calls will continue until a base case is reached. The base case causes the return to the caller and successive returns occur until the original call is reached. Recursion methods have the following characteristics:
  • Every recursive definition must have at least one base case.
  • Every recursive definition will have a recursive case.
  • The recursive case must eventually reduce to the base case.
  • The base case stops the recursion.


• Reference Number JavaScript RegExp
Here, we are using this term in regards to complex grouping patterns. Groups that create references are called capturing groups. Reference numbers are assigned from left to right in the pattern that contains the groupings. The uses for the reference number are:
  • backreferencing: a pattern can reference a former group (the group and backreference are in the same pattern)
  • replace method of the String object


• Reference Type: JavaScript Data Type
A reference type is a special data type. A variable containing a reference type is a pointer to an object. Reference types differ from primitive types in that a variable of a primitive type will contain actual data reflective of the primitive type. Not so with a reference type, it contains a pointer to where the data of the object exists. Because objects will vary in size, they require additional memory management overhead and the reference type (pointer) helps in this matter. The reference type applies to the object groups: Function Types, Array Types and Object Types.

• ReferenceError Subclass: JavaScript Class
The JS interpreter can throw an instance of the ReferenceError subclass when you attempt to access a variable that does not exist. The JavaScript programmer can also create ReferenceError instances with the ReferenceError class constructor for the purpose of capturing the run-time exceptions. The ReferenceError 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.

• Regular Expression: JavaScript RegExp
Regular expressions are a means for testing for occurrences of patterns within strings. The idea for regular expressions is derived from Unix tools and implemented in languages such as "Perl". With JS, regular expressions are strings with a special syntax. JS supports regular expressions with the RegExp class. Regular expression patterns can be built with the RegExp class constructor. JS also allows regular expression patterns to be built with a special regular expression literal format.

• RegExp Class: JavaScript Class
The RegExp class is a JS Native Class that supports JS regular expressions. Object instances of the RegExp class type have access to the properties and methods of the RegExp class. See our link for class for the distinction between the terms "class" and "object".

• RegExp Literal: JavaScript RegExp
Regular expression literals are comprised of literal characters and meta characters. A regular expression literal has its own unique syntax. The regular expression literal is enclosed with a pair of slash "/" characters. The concept of regular expression literals is not unlike that of string literals, however string literals are enclosed with a pair of quotation marks. A variable assigned to a regular expression literal will acquire the properties and behavior of a RegExp object of the RegExp class type.

• RegExp Object: JavaScript Object
The RegExp object is an instance of the native RegExp class. That is, a RegExp object is created by using the RegExp constructor in a new expression, supplying a pattern as an argument.

• Reference Value: JavaScript Value
A reference value is a pointer to a location ( address ) in memory where the object is stored. If you are familiar with the memory management terms heap and stack, then, pointers reside in the stack. They point to the actual object that resides in the heap.

• Relational Operator Group: JavaScript Operator
The relational operator group is an ECMAScript term that includes operators: less than and greater than operators.

• Relative Reference: Web
You can write a URI in one of two methods: absolute or relative. A relative URI is a Web address that is relative to the current source document or the base URI. The relative URI address is expressed with a relative path. Note that with the CSS <uri> data type, the base URI is that of the style sheet.

• Reluctant Quantifier: JavaScript RegExp
A greedy quantifier can be altered to a reluctant qualifier by placing the question mark after another quantifier. Remember how the greedy quantifier works (loops through the string, eliminating the last character of the string with each loop until the string has been exhausted or until a match occurs). The reluctant quantifier does the reverse of the greedy:
  1. It starts at the beginning of the target string (greedy starts at the end).
  2. It begins with the first character only (greedy starts with all characters of the target string).
  3. If no match, it adds the next (second) character to the match (greedy eliminates the last character of the target string).
  4. The repetition (match attempt, no match, add a character, match attempt, .....) continues until there is a match or the target string is fully represented in the match (the greedy process continues until there is a match or until all characters are eliminated from the target string).


• Remainder Operator: JavaScript Operator
The remainder operator is another name for the modulus operator.

• Rendered Content: CSS 2.1 Specification
The content of an element after the rendering that applies to it according to the relevant style sheets has been applied. How a replaced element's content is rendered is not defined by this specification. Rendered content may also be alternate text for an element (e.g., the value of the XHTML "alt" attribute), and may include items inserted implicitly or explicitly by the style sheet, such as bullets, numbering, etc.

• Repetition: JavaScript Term
As used here, repetition applies to a program control structure that facilitates a program loop. Each iteration of the loop repeats the same set of instructions. A repetitive structure has the following characteristics:
  • control statement: is where the test is performed to control loop iteration.
  • loop body: the statements (excluding the control statement) that are processed with each iteration.
Repetition structures can sometimes be replaced with recursive structures.

• Repetition Quantifier: JavaScript RegExp
Repetition Quantifier are regular expression meta characters that specify and control regular expression matching repetition. The repetition quantifiers must follow the pattern on which the repetition is based. Quantifiers are intrinsically greedy. The greedy quantifier can be changed to a reluctant quantifier by placing an additional question mark after the greedy quantifier. The greedy quantifier can be changed to a possessive quantifier by placing an additional plus sign after the greedy quantifier.

• Replaced Element: CSS 2.1 Specification
The replaced element is An element whose content is outside the scope of the CSS formatting model, such as an image, embedded document, or applet. For example, the content of the HTML IMG element is often replaced by the image that its "src" attribute designates. Replaced elements often have intrinsic dimensions: an intrinsic width, an intrinsic height, and an intrinsic ratio. For example, a bitmap image has an intrinsic width and an intrinsic height specified in absolute units (from which the intrinsic ratio can obviously be determined). On the other hand, other documents may not have any intrinsic dimensions (for example a blank HTML document). User agents may consider a replaced element to not have any intrinsic dimensions if it is believed that those dimensions could leak sensitive information to a third party. For example, if an HTML document changed intrinsic size depending on the user's bank balance, then the UA might want to act as if that resource had no intrinsic dimensions. The HTML elements that meet this distinction are:
  • img
  • applet
  • input
  • object
  • select
  • textarea


• Reserved Words: JavaScript Token
A reserved word is used for some grammatical purpose in a programming language and cannot be used as an identifier. The JS language keyword set is a sub-set of the reserved word set. In addition to keywords, the reserve word set contains any word planned for future use by the JS language.

• Return Results (return a value): JavaScript Term
We can use the term return results with many JS scenarios:
  • operators:
  • generally, operators will either return a value or cause a side effect,
  • functions: functions will return a result, either explicitly with a return statement of implicitly; an implicit return value is always undefined,
  • statements: the return statement will return a value


• return Statement: JavaScript Term
The return statement may appear inside of a function. The function body is the only valid place for return statements, however, there presense is not mandatory. The return statement causes the function to cease execution. The return statement syntax includes an optional expression. When the optional expression is present, it is evaluated and returned as the value of the function. When the optional expression is omitted from the return statement, the value returned is undefined.

• Right Shift Operator( Signed ): JavaScript Operator
The signed right shift operator ( symbol: >> ) is a binary operator with integer operands. It shifts all bits of the first operand to the right by the number specified in the second operand. The right shift preserves the sign of the original number whereby the sign bit ( bit-32 ) is shifted right ( 0 is shifted for positive numbers and 1 is shifted for negative numbers ). The 1st bit ( right most ) will be shifted out ( lost ) with each positioned shifted. The second operand should be an integer between 0 and 31.
The attributes of this operator are:

• Right Shift Operator ( Unsigned ): JavaScript Operator
The unsigned right shift operator ( symbol: >>> ) is exactly the same as the right shift operator except the bits shifted in on the left are always zero even with negative numbers. This operator is also called: right shift zero fill.
The attributes of this operator are:

• Root Element: CSS Property
The root element pertains to the document tree. In the document tree, each element has exactly one parent element, except for the root element. The root element has no parent. All other elements will descend from the root element. For HTML documents, the HTML opening tag serves as the root element.

• Rule, CSS: CSS Structure
A CSS rule consists of one or more property declarations for a given selector. Each CSS rule has a given structure with two main componets; the selector is on the left and the declaration block is on the right. The declaration block can consist of one or more property declarations. Each property declaration consists of a CSS property followed by the value assigned to the property. The CSS rule conforms to a predefined rule syntax.

• Rule Syntax: CSS Structure
The basic CSS rule syntax will conform to the following structure and syntax:
  • curly braces: will enclose the property declaration block and will separate this block from the selector,
  • semicolon: will separate each property declaration from subsequent property declarations, the semicolon for the last declaration is optional,
  • colon: will follow the property name and separates same from the property value,
  • white space: spaces are not required for the basic rule syntax, however, the syntax rules for certain property value specifications may acknowledge white space,
  • comments: the optional CSS comments are distinguished and enclosed by the /*....*/.
body{   font-family: Arial,Helvetica,sans-serif;   font-weight: 500;   color: #000080; /* darkblue for text */   line-height: 1.166;   margin: 0px 0px 0px 0px; /*Four values: top, right, bottom and left respectively*/   padding: 0px 0px 0px 0px; /*Four values: top, right, bottom and left respectively*/ }
Note that property values take on additional syntax patterns. We address this syntax with each property definition.















Top            

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