title
stringlengths 2
136
| text
stringlengths 20
75.4k
|
|---|---|
WebExtensions - MDN Web Docs Glossary: Definitions of Web-related terms | WebExtensions
=============
WebExtensions is a cross-browser system for developing browser extensions in Firefox. This system provides APIs, which to a large extent are supported across different browsers like Mozilla Firefox, Google Chrome, Opera Browser, Microsoft Edge, or Apple Safari.
See also
--------
* Browser extensions on MDN |
Bounding Box - MDN Web Docs Glossary: Definitions of Web-related terms | Bounding Box
============
The bounding box of an element is the smallest possible rectangle (aligned with the axes of that element's user coordinate system) that entirely encloses it and its descendants. |
RAIL - MDN Web Docs Glossary: Definitions of Web-related terms | RAIL
====
**RAIL**, an acronym for **Response, Animation, Idle, and Load**, is a performance model originated by the Google Chrome team in 2015, focused on user experience and performance within the browser. The performance mantra of RAIL is "Focus on the user; the end goal isn't to make your site perform fast on any specific device, it's to make users happy." There are 4 stages of interaction: page load, idle, response to input, and scrolling and animation. In acronym order, the main tenets are:
**Response**
Respond to users immediately, acknowledging any user input in **100ms** or less.
**Animation**
When animating, render each frame in under **16ms**, aiming for consistency and avoiding jank.
**Idle**
When using the main JavaScript thread, work in chunks for less than **50ms** to free up the thread for user interactions.
**Load**
Deliver interactive content in less than **1 second**.
See also
--------
* Recommended Web Performance Timings: How long is too long |
Algorithm - MDN Web Docs Glossary: Definitions of Web-related terms | Algorithm
=========
An **algorithm** is a self-contained series of instructions to perform a function.
In other words, an algorithm is a means of describing a way to solve a problem so that it can be solved repeatedly, by humans or machines. Computer scientists compare the efficiency of algorithms through the concept of "Algorithmic Complexity" or "Big O" notation.
For example:
* A cooking recipe is a simple algorithm for humans.
* A sorting algorithm is often used in computer programming to explain to a machine how to sort data.
Common algorithms are Pathfinding algorithms such as the optimization Traveling Salesman Problem, Tree Traversal algorithms, and so on.
There are also Machine Learning algorithms such as Linear Regression, Logistic Regression, Decision Tree, Random Forest, Support Vector Machine, Recurrent Neural Network (RNN), Long Short Term Memory (LSTM) Neural Network, Convolutional Neural Network (CNN), Deep Convolutional Neural Network, and so on.
See also
--------
* Algorithm on Wikipedia
* Explanations of sorting algorithms
* Explanations of algorithmic complexity |
Grid container - MDN Web Docs Glossary: Definitions of Web-related terms | Grid container
==============
Using the value `grid` or `inline-grid` on an element turns it into a **grid container** using CSS Grid Layout, and any direct children of this element become grid items.
When an element becomes a grid container it establishes a **grid formatting context**. The direct children can now lay themselves out on any explicit grid defined using `grid-template-columns` and `grid-template-rows`, or on the *implicit grid* created when an item is placed outside of the *explicit grid*.
See also
--------
### Property reference
* `grid-template-columns`
* `grid-template-rows`
* `grid-auto-columns`
* `grid-auto-rows`
* `grid`
* `grid-template`
### Further reading
* CSS Grid Layout guide: *Basic concepts of grid layout* |
GPL - MDN Web Docs Glossary: Definitions of Web-related terms | GPL
===
The (GNU) GPL (General Public License) is a copyleft free software license published by the Free Software Foundation. Users of a GPL-licensed program are granted the freedom to use it, read the source code, modify it and redistribute the changes they made, provided they redistribute the program (modified or unmodified) under the same license.
See also
--------
* FAQ on GNU licenses
* GNU GPL on Wikipedia
* GPL License text |
Namespace - MDN Web Docs Glossary: Definitions of Web-related terms | Namespace
=========
Namespace is a context for identifiers, a logical grouping of names used in a program. Within the same context and same scope, an identifier must uniquely identify an entity.
In an operating system, a directory is a namespace. Each file or subdirectory within a directory has a unique name; the same name can be used multiple times across subdirectories.
In HTML, CSS, and XML-based languages, a namespace is the explicitly declared or implied dialect to which an element (or attribute) belongs.
See also
--------
* Namespaces crash course
* CSS namespaces module
* CSS `@namespace`
* `Document.createElementNS()` method
* Namespace on Wikipedia |
Entity - MDN Web Docs Glossary: Definitions of Web-related terms | Entity
======
An HTML **entity** is a piece of text ("string") that begins with an ampersand (`&`) and ends with a semicolon (`;`). HTML entities are frequently used to display reserved characters (which would otherwise be interpreted as HTML code), and invisible characters (like non-breaking spaces). You can also use HTML character entities in place of other characters that are difficult to type with a standard keyboard.
**Note:** Many characters have memorable entities. For example, the entity for the copyright symbol (`©`) is `©`. For less memorable characters, such as `—` or `—`, you can use a reference chart or decoder tool.
Reserved characters
-------------------
Some special characters are reserved for use in HTML, meaning that your browser will parse them as HTML code. For example, if you use the less-than (`<`) sign, the browser interprets any text that follows as a tag.
To display these characters as text, replace them with their corresponding character entities, as shown in the following table.
| Character | Entity | Note |
| --- | --- | --- |
| & | `&` | Interpreted as the beginning of an entity or character reference. |
| < | `<` | Interpreted as the beginning of a tag |
| > | `>` | Interpreted as the ending of a tag |
| " | `"` | Interpreted as the beginning and end of an attribute's value. |
| | ` ` | Interpreted as the non breaking space. |
| – | `–` | Interpreted as the en dash (half the width of an em unit). |
| — | `—` | Interpreted as the em dash (equal to width of an "m" character). |
| © | `©` | Interpreted as the copyright sign. |
| ® | `®` | Interpreted as the registered sign. |
| ™ | `™` | Interpreted as the trademark sign. |
| ≈ | `≈` | Interpreted as almost equal to sign. |
| ≠ | `≠` | Interpreted as not equal to sign. |
| £ | `£` | Interpreted as the pound symbol. |
| € | `€` | Interpreted as the euro symbol. |
| ° | `°` | Interpreted as the degree symbol. |
See also
--------
* Official list of character entities |
OOP - MDN Web Docs Glossary: Definitions of Web-related terms | OOP
===
**OOP** (Object-Oriented Programming) is an approach in programming in which data is encapsulated within **objects** and the object itself is operated on, rather than its component parts.
JavaScript is heavily object-oriented. It follows a **prototype**-based model, but it also offers a class syntax to enable typical OOP paradigms.
See also
--------
* Object-oriented programming on Wikipedia
* Introduction to object-oriented JavaScript
* Inheritance and the prototype chain |
Boolean - MDN Web Docs Glossary: Definitions of Web-related terms | Boolean
=======
In computer science, a **Boolean** is a logical data type that can have only the values `true` or `false`.
For example, in JavaScript, Boolean conditionals are often used to decide which sections of code to execute (such as in if statements) or repeat (such as in for loops).
Below is some JavaScript pseudocode (it's not truly executable code) demonstrating this concept.
```js
/\* JavaScript if statement \*/
if (boolean conditional) {
// code to execute if the conditional is true
}
if (boolean conditional) {
console.log("boolean conditional resolved to true");
} else {
console.log("boolean conditional resolved to false");
}
/\* JavaScript for loop \*/
for (control variable; boolean conditional; counter) {
// code to execute repeatedly if the conditional is true
}
```
The Boolean value is named after English mathematician George Boole, who pioneered the field of mathematical logic.
Above is a general introduction. The term **Boolean** can have more specific meanings depending on the context. It may refer to:
Boolean (JavaScript)
A **Boolean** in JavaScript is a Primitive that can be either `true` or `false`.
Boolean attribute (ARIA)
A **boolean attribute** in ARIA is an Enumerated that includes `true` or `false` in the enumerated list.
Boolean attribute (HTML)
A **boolean attribute** in HTML is an attribute that represents `true` or `false` values. If an HTML tag contains a boolean attribute - no matter the value of that attribute - the attribute is set to `true` on that element. If an HTML tag does not contain the attribute, the attribute is set to `false`.
See also
--------
* Boolean on Wikipedia |
Grid Column - MDN Web Docs Glossary: Definitions of Web-related terms | Grid Column
===========
A **grid column** is a vertical track in a CSS Grid Layout, and is the space between two vertical grid lines. It is defined by the `grid-template-columns` property or in the shorthand `grid` or `grid-template` properties.
In addition, columns may be created in the *implicit grid* when items are placed outside of columns created in the *explicit grid*. These columns will be auto-sized by default, or can have a size specified with the `grid-auto-columns` property.
When working with alignment in CSS Grid Layout, the axis down which columns run is known as the *block, or column, axis*.
See also
--------
### Property reference
* `grid-template-columns`
* `grid-auto-columns`
* `grid`
* `grid-template`
### Further reading
* CSS Grid Layout Guide: *Basic concepts of grid layout* |
Placeholder names - MDN Web Docs Glossary: Definitions of Web-related terms | Placeholder names
=================
Placeholder names are commonly used in cryptography to indicate the participants in a conversation, without resorting to terminology such as "Party A," "eavesdropper," and "malicious attacker."
The most commonly used names are:
* *Alice* and *Bob*, two parties who want to send messages to each other, occasionally joined by *Carol*, a third participant
* *Eve*, a passive attacker who is eavesdropping on Alice and Bob's conversation
* *Mallory*, an active attacker ("man-in-the-middle") who is able to modify their conversation and replay old messages |
Computer Programming - MDN Web Docs Glossary: Definitions of Web-related terms | Computer Programming
====================
Computer programming is a process of composing and organizing a collection of instructions. These tell a computer/software program what to do in a language which the computer understands. These instructions come in the form of many different languages such as C++, Java, JavaScript, HTML, Python, Ruby, and Rust.
Using an appropriate language, you can program/create all sorts of software. For example, a program that helps scientists with complex calculations, a database that stores huge amounts of data, a website that allows people to download music, or animation software that allows people to create animated movies.
See also
--------
* Computer programming on Wikipedia
* List of Programming Languages: Wikipedia |
Plaintext - MDN Web Docs Glossary: Definitions of Web-related terms | Plaintext
=========
Plaintext refers to information that is being used as an input to an encryption algorithm, or to ciphertext that has been decrypted.
It is frequently used interchangeably with the term *cleartext*, which more loosely refers to any information, such as a text document, image, etc., that has not been encrypted and can be read by a human or computer without additional processing. |
Visual Viewport - MDN Web Docs Glossary: Definitions of Web-related terms | Visual Viewport
===============
The portion of the viewport that is currently visible is called the visual viewport. This can be smaller than the layout viewport, such as when the user has pinched-zoomed. The visual viewport is the visual portion of a screen excluding on-screen keyboards, areas outside of a pinch-zoom area, or any other on-screen artifact that doesn't scale with the dimensions of a page.
See also
--------
* Visual Viewport API
* Viewport on Wikipedia
* A tale of two viewports (Quirksmode)
* Viewport in the MDN Glossary
* Layout viewport in the MDN Glossary |
Camel case - MDN Web Docs Glossary: Definitions of Web-related terms | Camel case
==========
**Camel case** is a way of writing phrases without spaces, where the first letter of each word is capitalized, except for the first letter of the entire compound word, which may be either upper or lower case. The name comes from the similarity of the capital letters to the humps of a camel's back. It's often stylized as "camelCase" to remind the reader of its appearance.
Camel casing is often used as a variable naming convention. The following variables are in camel case: `console`, `crossOriginIsolated`, `encodeURIComponent`, `ArrayBuffer`, and `HTMLElement`.
Note that if the phrase contains acronyms (such as `URI` and `HTML`), camel casing practices vary. Some prefer to keep all of them capitalized, such as `encodeURIComponent` above. This may sometimes lead to ambiguity with multiple consecutive acronyms, such as `XMLHTTPRequest`. Others prefer to only capitalize the first letter, as `XmlHttpRequest`. The actual global variable, `XMLHttpRequest`, uses a mix of both.
When the first letter of the entire phrase is upper case, it is called *upper camel case* or *Pascal case*. Otherwise, it is called *lower camel case*.
Camel case is the most popular convention in JavaScript, Java, and various other languages.
See also
--------
* Snake case
* Kebab case
* typescript-eslint rule: `naming-convention` |
Browser - MDN Web Docs Glossary: Definitions of Web-related terms | Browser
=======
A **Web browser** or **browser** is a program that retrieves and displays pages from the Web, and lets users access further pages through hyperlinks. A browser is the most familiar type of user agent.
See also
--------
* Web browser on Wikipedia
* user agent (Glossary)
* `User-agent` (HTTP Header)
* Download a browser
+ Mozilla Firefox
+ Google Chrome
+ Microsoft Edge
+ Opera Browser |
BigInt - MDN Web Docs Glossary: Definitions of Web-related terms | BigInt
======
In JavaScript, **BigInt** is a numeric data type that can represent integers in the arbitrary precision format. In other programming languages different numeric types can exist, for examples: Integers, Floats, Doubles, or Bignums.
See also
--------
* Numeric types on Wikipedia
* The JavaScript type: `BigInt`
* The JavaScript global object `BigInt` |
Three js - MDN Web Docs Glossary: Definitions of Web-related terms | Three js
========
three.js is a JavaScript-based WebGL engine that can run GPU-powered games and other graphics-powered apps straight from the browser. The three.js library provides many features and APIs for drawing 3D scenes in your browser.
See also
--------
* Three.js on Wikipedia
* three.js official website |
Native - MDN Web Docs Glossary: Definitions of Web-related terms | Native
======
A *native* application has been compiled to run on the hardware/software environment that comprises the targeted architecture.
An example of a native Android app would be a mobile application written in Java using the Android toolchain.
On the other hand, a Web App that runs inside a browser is not native — it is run in the web browser, which sits on top of the native environment, not the native environment itself.
See also
--------
* Native (computing) on Wikipedia |
OpenSSL - MDN Web Docs Glossary: Definitions of Web-related terms | OpenSSL
=======
OpenSSL is an open-source implementation of TLS and SSL.
See also
--------
* OpenSSL on Wikipedia
* Official website |
CORS-safelisted request header - MDN Web Docs Glossary: Definitions of Web-related terms | CORS-safelisted request header
==============================
A CORS-safelisted request header is one of the following HTTP headers:
* `Accept`,
* `Accept-Language`,
* `Content-Language`,
* `Content-Type`,
* `Range`.
When containing only these headers (and values that meet the additional requirements laid out below), a request doesn't need to send a preflight request in the context of CORS.
You can safelist more headers using the `Access-Control-Allow-Headers` header and also list the above headers there to circumvent the following additional restrictions.
Additional restrictions
-----------------------
CORS-safelisted headers must also fulfill the following requirements in order to be a CORS-safelisted request header:
* `Accept-Language` and `Content-Language` can only have values consisting of `0-9`, `A-Z`, `a-z`, space or `*,-.;=`.
* `Accept` and `Content-Type` can't contain a *CORS-unsafe request header byte*: `0x00-0x1F` (except for `0x09 (HT)`, which is allowed), `"():<>?@[\]{}`, and `0x7F (DEL)`.
* `Content-Type` needs to have a MIME type of its parsed value (ignoring parameters) of either `application/x-www-form-urlencoded`, `multipart/form-data`, or `text/plain`.
* `Range` needs to have a value of a single byte range in the form of `bytes=[0-9]+-[0-9]*`.
See the `Range` header documentation for more details.
* For any header: the value's length can't be greater than 128.
See also
--------
* CORS-safelisted response header
* Forbidden header name
* Request header |
Snap positions - MDN Web Docs Glossary: Definitions of Web-related terms | Snap positions
==============
Snap positions are points where the scrollport stops moving after the scrolling operation completes. Setting up snap positions allows to create a scrolling experience of paging through content instead of needing to drag content into view.
Snap positions are set up on a scroll container. See the CSS Scroll Snap properties. |
CRLF - MDN Web Docs Glossary: Definitions of Web-related terms | CRLF
====
CR and LF are control characters or bytecode that can be used to mark a line break in a text file.
* CR = **Carriage Return** (`\r`, `0x0D` in hexadecimal, 13 in decimal) — moves the cursor to the beginning of the line without advancing to the next line.
* LF = **Line Feed** (`\n`, `0x0A` in hexadecimal, 10 in decimal) — moves the cursor down to the next line without returning to the beginning of the line.
A CR immediately followed by a LF (CRLF, `\r\n`, or `0x0D0A`) moves the cursor to the beginning of the line and then down to the next line.
See also
--------
* Newline on Wikipedia
* Carriage return on Wikipedia |
SCM - MDN Web Docs Glossary: Definitions of Web-related terms | SCM
===
SCM (Source Control Management) is a system for managing source code. Usually it refers to the use of software to handle versioning of source files. A programmer can modify source code files without being afraid of editing out useful stuff, because a SCM keeps track of how the source code has changed and who made the changes.
Some SCM systems include CVS, SVN, GIT.
See also
--------
* Revision control on Wikipedia |
SOAP - MDN Web Docs Glossary: Definitions of Web-related terms | SOAP
====
**SOAP** (Simple Object Access Protocol) is a protocol for transmitting data in XML format.
See also
--------
* SOAP on Wikipedia
* Specification |
Synthetic monitoring - MDN Web Docs Glossary: Definitions of Web-related terms | Synthetic monitoring
====================
**Synthetic monitoring** involves monitoring the performance of a page in a 'laboratory' environment, typically with automation tooling in an environment that is as consistent as possible.
With a consistent baseline, synthetic monitoring is good for measuring the effects of code changes on performance. However, it doesn't necessarily reflect what users are experiencing.
Synthetic Monitoring involves deploying scripts to simulate the path an end-user might take through a web application, reporting back the performance of the simulator experiences. Examples of popular synthetic monitoring tools include WebPageTest and Lighthouse. The traffic measured is not of your actual users, but rather synthetically generated traffic collecting data on page performance.
Unlike RUM, synthetic monitoring provides a narrow view of performance that doesn't account for user differences, making it useful in getting basic data about an application's performance and spot-checking performance in development environments. Combined with other tools, such as network throttling, can provide excellent insight into potential problem areas.
See also
--------
* Real User Monitoring (RUM)
* Real User Monitoring (RUM) versus Synthetic Monitoring
* Beacon |
CSS preprocessor - MDN Web Docs Glossary: Definitions of Web-related terms | CSS preprocessor
================
A **CSS preprocessor** is a program that lets you generate CSS from the preprocessor's own unique syntax.
There are many CSS preprocessors to choose from, however most CSS preprocessors will add some features that don't exist in pure CSS, such as mixin, nesting selector, inheritance selector, and so on. These features make the CSS structure more readable and easier to maintain.
To use a CSS preprocessor, you must install a CSS compiler on your web server; Or use the CSS preprocessor to compile on the development environment, and then upload compiled CSS file to the web server.
See also
--------
* A few of most popular CSS preprocessors:
+ Sass
+ LESS
+ Stylus
+ PostCSS
* MDN Web Docs Glossary
+ CSS |
First paint - MDN Web Docs Glossary: Definitions of Web-related terms | First paint
===========
**First Paint** is the time between navigation and when the browser first renders pixels to the screen, rendering anything that is visually different from the default background color of the body. It is the first key moment in page load and will answer the question "Has the browser started to render the page?"
See also
--------
* First contentful paint
* `PerformancePaintTiming`
* Largest Contentful Paint
* First meaningful paint |
Syntax error - MDN Web Docs Glossary: Definitions of Web-related terms | Syntax error
============
An exception caused by the incorrect use of a pre-defined syntax. Syntax errors are detected while compiling or parsing source code.
For example, if you leave off a closing brace (`}`) when defining a JavaScript function, you trigger a syntax error. Browser development tools display JavaScript and CSS syntax errors in the console.
See also
--------
* Syntax error on Wikipedia
* `SyntaxError` JavaScript object |
Inheritance - MDN Web Docs Glossary: Definitions of Web-related terms | Inheritance
===========
Inheritance is a major feature of object-oriented programming. Data abstraction can be carried up several levels, that is, classes can have superclasses and subclasses.
As an app developer, you can choose which of the superclass's attributes and methods to keep and add your own, making class definition very flexible. Some languages let a class inherit from more than one parent (multiple inheritance).
See also
--------
* Inheritance and the prototype chain |
Reporting directive - MDN Web Docs Glossary: Definitions of Web-related terms | Reporting directive
===================
**CSP reporting directives** are used in a `Content-Security-Policy` header and control the reporting process of CSP violations.
See Reporting directives for a complete list.
See also
--------
* Glossary
+ CSP
+ Fetch directive
+ Document directive
+ Navigation directive
* Reference
+ https://www.w3.org/TR/CSP/#directives-reporting
+ `upgrade-insecure-requests`
+ `block-all-mixed-content`
+ `Content-Security-Policy` |
Quaternion - MDN Web Docs Glossary: Definitions of Web-related terms | Quaternion
==========
A **quaternion** is the quotient of two 3D vectors and is used in 3D graphics and in accelerometer-based sensors to represent orientation or rotational data.
While mathematical quaternions are more involved than this, the **unit quaternions** (or **rotational quaternions**) used to represent rotation while using WebGL or WebXR, for example, are represented using the same syntax as a 3D point. As such, the type `DOMPoint` (or `DOMPointReadOnly`) is used to store quaternions.
See also
--------
* Quaternions and spatial rotation on Wikipedia
* Quaternion on Wikipedia
* `XRRigidTransform.orientation` in the WebXR Device API reference |
Transient activation - MDN Web Docs Glossary: Definitions of Web-related terms | Transient activation
====================
**Transient activation** (or "transient user activation") is a window state that indicates a user has recently pressed a button, moved a mouse, used a menu, or performed some other user interaction.
This state is sometimes used as a mechanism for ensuring that a web API can only function if triggered by user interaction.
For example, scripts cannot arbitrarily launch a popup that requires *transient activation* —it must be triggered from a UI element's event handler.
See Features gated by user activation for examples of APIs that require *transient activation*.
See the `UserActivation.isActive` property to programmatically access the current window's transient activation state.
**Note:** Transient activation expires after a timeout (if not renewed by further interaction), and may also be "consumed" by some APIs. See Sticky activation for a user activation that doesn't reset after it has been set initially.
See also
--------
* HTML Living Standard > Transient activation
* Sticky activation
* `UserActivation.isActive` |
HTML - MDN Web Docs Glossary: Definitions of Web-related terms | HTML
====
**HTML** (HyperText Markup Language) is a descriptive language that specifies webpage structure.
Brief history
-------------
In 1990, as part of his vision of the Web, Tim Berners-Lee defined the concept of hypertext, which Berners-Lee formalized the following year through a markup mainly based on SGML. The IETF began formally specifying HTML in 1993, and after several drafts released version 2.0 in 1995. In 1994 Berners-Lee founded the W3C to develop the Web. In 1996, the W3C took over the HTML work and published the HTML 3.2 recommendation a year later. HTML 4.0 was released in 1999 and became an ISO standard in 2000.
At that time, the W3C nearly abandoned HTML in favor of XHTML, prompting the founding of an independent group called WHATWG in 2004. Thanks to WHATWG, work on HTML continued: the two organizations released the first draft of HTML5 in 2008 and an official standard in 2014. The term "HTML5" is just a buzzword referring to modern web technologies which are part of the HTML Living Standard.
Concept and syntax
------------------
An HTML document is a plaintext document structured with elements. Elements are surrounded by matching opening and closing tags. Each tag begins and ends with angle brackets (`<>`). There are a few empty or *void* elements that cannot enclose any text, for instance `<img>`.
You can extend HTML tags with attributes, which provide additional information affecting how the browser interprets the element:
An HTML file is normally saved with an `.htm` or `.html` extension, served by a web server, and can be rendered by any Web browser.
See also
--------
* HTML on Wikipedia
* Our HTML tutorial
* The web course on codecademy.com
* The HTML documentation on MDN
* The HTML specification |
UX - MDN Web Docs Glossary: Definitions of Web-related terms | UX
==
**UX** is an acronym that stands for User eXperience. It is the study of the interaction between users and a system. Its goal is to make a system easy to interact with from the user's point of view.
The system can be any kind of product or application that an end user is meant to interact with. UX studies undertaken on a web page for example can demonstrate whether it is easy for users to understand the page, navigate to different areas, and complete common tasks, and where such processes could have less friction.
See also
--------
* User experience on Wikipedia |
Encapsulation - MDN Web Docs Glossary: Definitions of Web-related terms | Encapsulation
=============
Encapsulation is the packing of data and functions into one component (for example, a class) and then controlling access to that component to make a "blackbox" out of the object. Because of this, a user of that class only needs to know its interface (that is, the data and functions exposed outside the class), not the hidden implementation.
See also
--------
* Encapsulation on Wikipedia |
Callback function - MDN Web Docs Glossary: Definitions of Web-related terms | Callback function
=================
A **callback function** is a function passed into another function as an argument, which is then invoked inside the outer function to complete some kind of routine or action.
The consumer of a callback-based API writes a function that is passed into the API. The provider of the API (called the *caller*) takes the function and calls back (or executes) the function at some point inside the caller's body. The caller is responsible for passing the right parameters into the callback function. The caller may also expect a particular return value from the callback function, which is used to instruct further behavior of the caller.
There are two ways in which the callback may be called: *synchronous* and *asynchronous*. Synchronous callbacks are called immediately after the invocation of the outer function, with no intervening asynchronous tasks, while asynchronous callbacks are called at some point later, after an asynchronous operation has completed.
Understanding whether the callback is synchronously or asynchronously called is particularly important when analyzing side effects. Consider the following example:
```js
let value = 1;
doSomething(() => {
value = 2;
});
console.log(value);
```
If `doSomething` calls the callback synchronously, then the last statement would log `2` because `value = 2` is synchronously executed; otherwise, if the callback is asynchronous, the last statement would log `1` because `value = 2` is only executed after the `console.log` statement.
Examples of synchronous callbacks include the callbacks passed to `Array.prototype.map()`, `Array.prototype.forEach()`, etc. Examples of asynchronous callbacks include the callbacks passed to `setTimeout()` and `Promise.prototype.then()`.
The Using promises guide has more information on the timing of asynchronous callbacks.
See also
--------
* Callback on Wikipedia |
Parse - MDN Web Docs Glossary: Definitions of Web-related terms | Parse
=====
Parsing means analyzing and converting a program into an internal format that a runtime environment can actually run, for example the JavaScript engine inside browsers.
The browser parses HTML into a DOM tree. HTML parsing involves tokenization and tree construction. HTML tokens include start and end tags, as well as attribute names and values. If the document is well-formed, parsing it is straightforward and faster. The parser parses tokenized input into the document, building up the document tree.
When the HTML parser finds non-blocking resources, such as an image, the browser will request those resources and continue parsing. Parsing can continue when a CSS file is encountered, but `<script>` tags—particularly those without an `async` or `defer` attribute—blocks rendering, and pauses parsing of HTML.
When the browser encounters CSS styles, it parses the text into the CSS Object Model (or CSSOM), a data structure it then uses for styling layouts and painting. The browser then creates a render tree from both these structures to be able to paint the content to the screen. JavaScript is also downloaded, parsed, and then executed.
JavaScript parsing is done during compile time or whenever the parser is invoked, such as during a call to a method.
See also
--------
* Parse on Wikipedia |
UTF-8 - MDN Web Docs Glossary: Definitions of Web-related terms | UTF-8
=====
UTF-8 (UCS Transformation Format 8) is the World Wide Web's most common character encoding. Each character is represented by one to four bytes. UTF-8 is backward-compatible with ASCII and can represent any standard Unicode character.
The first 128 UTF-8 characters precisely match the first 128 ASCII characters (numbered 0-127), meaning that existing ASCII text is already valid UTF-8. All other characters use two to four bytes. Each byte has some bits reserved for encoding purposes. Since non-ASCII characters require more than one byte for storage, they run the risk of being corrupted if the bytes are separated and not recombined.
See also
--------
* UTF-8 on Wikipedia
* FAQ about UTF-8 on Unicode website |
CSRF - MDN Web Docs Glossary: Definitions of Web-related terms | CSRF
====
**CSRF** (Cross-Site Request Forgery) is an attack that impersonates a trusted user and sends a website unwanted commands.
This can be done, for example, by including malicious parameters in a URL behind a link that purports to go somewhere else:
```html
<img src="https://www.example.com/index.php?action=delete&id=123" />
```
For users who have modification permissions on `https://www.example.com`, the `<img>` element executes action on `https://www.example.com` without their noticing, even if the element is not at `https://www.example.com`.
There are many ways to prevent CSRF, such as implementing RESTful API, adding secure tokens, etc.
See also
--------
* Cross-site request forgery on Wikipedia
* Prevention measures |
Statement - MDN Web Docs Glossary: Definitions of Web-related terms | Statement
=========
In a computer programming language, a **statement** is a line of code commanding a task. Every program consists of a sequence of statements.
See also
--------
* Statement (computer science) on Wikipedia
* JavaScript statements and declarations |
Web server - MDN Web Docs Glossary: Definitions of Web-related terms | Web server
==========
A web server is a piece of software that often runs on a hardware server offering service to a user, usually referred to as the client. A server, on the other hand, is a piece of hardware that lives in a room full of computers, commonly known as a data center.
See also
--------
* Introduction to servers
* Server (computing) on Wikipedia |
Quality values - MDN Web Docs Glossary: Definitions of Web-related terms | Quality values
==============
**Quality values**, or *q-values* and *q-factors*, are used to describe the order of priority of values in a comma-separated list. It is a special syntax allowed in some HTTP headers and in HTML.
The importance of a value is marked by the suffix `';q='` immediately followed by a value between `0` and `1` included, with up to three decimal digits, the highest value denoting the highest priority. When not present, the default value is `1`.
Examples
--------
The following syntax
```http
text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
```
indicates the order of priority:
| Value | Priority |
| --- | --- |
| `text/html` and `application/xhtml+xml` | `1.0` |
| `application/xml` | `0.9` |
| `*/*` | `0.8` |
If there is no priority defined for the first two values, the order in the list is irrelevant. Nevertheless, with the same quality, more specific values have priority over less specific ones:
```http
text/html;q=0.8,text/*;q=0.8,*/*;q=0.8
```
| Value | Priority |
| --- | --- |
| `text/html` | `0.8` (but totally specified) |
| `text/*` | `0.8` (partially specified) |
| `*/*` | `0.8` (not specified) |
Some syntax, like the one of `Accept`, allow additional specifiers like `text/html;level=1`. These increase the specificity of the value. Their use is extremely rare.
More information
----------------
* HTTP headers using q-values in their syntax: `Accept`, `Accept-Encoding`, `Accept-Language`, `TE`, `Want-Digest`.
* Header field definitions. |
Progressive web apps - MDN Web Docs Glossary: Definitions of Web-related terms | Progressive web apps
====================
Progressive web applications (PWA) are applications that are built using web platform technologies, but that provide a user experience like that of a platform-specific app.
These kinds of apps enjoy all the best parts of the Web — such as discoverability via search engines, being linkable via URLs, and working across multiple form factors, but are progressively enhanced with modern APIs (such as Service Workers and Push).
These features include being installable, working offline, and being easy to sync with and re-engage the user from the server.
See also
--------
* Progressive web apps on MDN
* Progressive web apps on web.dev |
SEO - MDN Web Docs Glossary: Definitions of Web-related terms | SEO
===
**SEO** (Search Engine Optimization) is the process of making a website more visible in search results, also termed improving search rankings.
Search engines crawl the web, following links from page to page, and index the content found. When you search, the search engine displays the indexed content. Crawlers follow rules. If you follow those rules closely when doing SEO for a website, you give the site the best chances of showing up among the first results, increasing traffic and possibly revenue (for e-commerce and ads).
Search engines give some guidelines for SEO, but big search engines keep result ranking as a trade secret. SEO combines official search engine guidelines, empirical knowledge, and theoretical knowledge from science papers or patents.
SEO methods fall into three broad classes:
Technical
Tag the content using semantic HTML. When exploring the website, crawlers should only find the content you want indexed.
Copywriting
Write content using your visitors' vocabulary. Use text as well as images so that crawlers can understand the subject.
Popularity
You get most traffic when other established sites link to your site.
See also
--------
* SEO on Wikipedia
* Google Search Central |
JSON type representation - MDN Web Docs Glossary: Definitions of Web-related terms | JSON type representation
========================
JSON is a convenient and widely used format for serializing objects, arrays, numbers, strings, booleans, and null.
JSON does not support all data types allowed by JavaScript, which means that JavaScript objects that use these incompatible types cannot be directly serialized to JSON.
The *JSON type representation* of a JSON-incompatible object is an equivalent JavaScript object with properties encoded such that the information *can* be serialized to JSON.
This typically has the same properties as the original object for compatible data types, while incompatible properties are converted/serialized to compatible types.
For example, buffer properties in the original object might be base64url-encoded to strings in the JSON-type representation.
An object that cannot automatically be serialized to JSON using the `JSON.stringify()` method can define an instance method named `toJSON()` that returns the *JSON-type representation* of the original object.
`JSON.stringify()` will then use `toJSON()` to get the object to stringify, instead of the original object.
`PublicKeyCredential.toJSON()` and `Performance.toJSON()` are examples of this approach.
A JSON string serialized in this way can be deserialized back to the *JSON-type representation* object using `JSON.parse()`.
It is common to provide a converter method, such as `PublicKeyCredential.parseCreationOptionsFromJSON()`, to convert the *JSON-type representation* back to the original object. |
Flexbox - MDN Web Docs Glossary: Definitions of Web-related terms | Flexbox
=======
Flexbox is the commonly-used name for the CSS Flexible Box Layout Module, a layout model for displaying items in a single dimension — as a row or as a column.
In the specification, Flexbox is described as a layout model for user interface design. The key feature of Flexbox is the fact that items in a flex layout can grow and shrink. Space can be assigned to the items themselves, or distributed between or around the items.
Flexbox also enables alignment of items on the main or cross axis, thus providing a high level of control over the size and alignment of a group of items.
See also
--------
### Property reference
* `align-content`
* `align-items`
* `align-self`
* `flex`
* `flex-basis`
* `flex-direction`
* `flex-flow`
* `flex-grow`
* `flex-shrink`
* `flex-wrap`
* `justify-content`
* `order`
### Further reading
* *CSS Flexible Box Layout Module Level 1 Specification*
* CSS Flexbox Guide:
+ Basic Concepts of Flexbox
+ Relationship of flexbox to other layout methods
+ Aligning items in a flex container
+ Ordering flex items
+ Controlling Ratios of flex items along the main axis
+ Mastering wrapping of flex items
+ Typical use cases of flexbox |
XQuery - MDN Web Docs Glossary: Definitions of Web-related terms | XQuery
======
**XQuery** is a computer language for updating, retrieving, and calculating data in XML databases.
See also
--------
* Official website
* XQuery on Wikipedia |
Perceived performance - MDN Web Docs Glossary: Definitions of Web-related terms | Perceived performance
=====================
**Perceived performance** is a measure of how fast, responsive, and reliable a website *feels* to its users. The perception of how well a site is performing can have more impact on the user experience than the actual load and response times.
See also
--------
* Perceived performance |
Gamut - MDN Web Docs Glossary: Definitions of Web-related terms | Gamut
=====
A color **gamut** is a subset of colors, usually representing the colors that a display or a printing device can represent.
No display or printer can represent the whole range of colors that a human eye can perceive. The device *gamut* represents the set that it supports.
Traditionally, in web development, the only gamut used was *sRGB* (Standard Red-Green-Blue), where each color is described using three bytes, one for each primary color. However, "wide-color" monitors and professional printers support a wider range of colors, that can't be represented using this gamut.
Since 2021, browsers have started to provide functionality for other gamuts, like *P3*, widely used in the movie industry, and *rec2020*.
Developers can define different sets of colors for devices supporting larger gamuts using the `color-gamut` media feature. They can describe colors outside the RGB gamut using specific CSS functions like `lch()` for the LCH cylindrical coordinate system, or `lab()` for the Lab coordinate system.
See also
--------
* *Gamut* on *Wikipedia*. |
ASCII - MDN Web Docs Glossary: Definitions of Web-related terms | ASCII
=====
**ASCII** (*American Standard Code for Information Interchange*) is a character encoding standard of 128 7-bit used by computers for converting letters, numbers, punctuation, and control codes into digital form.
The first 33 ASCII code points are non-printing control codes including the carriage return, line feed, tab, and several obsolete non-printable codes stemming from its origin of representing telegraph codes. The other 95 are printable characters, including digits (0-9), lowercase (a-z) and uppercase (A-Z) letters, and punctuation symbols.
Many computer systems instead use Unicode, which has millions of code points, but the first 128 of these are the same as the ASCII set. UTF-8 superseded ASCII on the Web in 2007.
See also
--------
* ASCII on Wikipedia |
XMLHttpRequest (XHR) - MDN Web Docs Glossary: Definitions of Web-related terms | XMLHttpRequest (XHR)
====================
`XMLHttpRequest` (XHR) is a JavaScript API to create HTTP requests. Its methods provide the ability to send network requests between the browser and a server.
The Fetch API is the modern replacement for XMLHttpRequest.
See also
--------
* The XMLHttpRequest API documentation. |
Web standards - MDN Web Docs Glossary: Definitions of Web-related terms | Web standards
=============
Web standards are rules established by international standards bodies and defining how the Web works (and sometimes controlling the Internet as well).
Several standards bodies are responsible for defining different aspects of the Web, and all the standards must coordinate to keep the Web maximally usable and accessible. Web standards also must evolve to improve the current status and adapt to new circumstances.
This non-exhaustive list gives you an idea of which standards websites and network systems must conform to:
* **IETF** (Internet Engineering Task Force): Internet standards (STD), which among other things govern set-up and use of URIs, HTTP, and MIME
* **W3C**: specifications for markup language (e.g., HTML), style definitions (i.e., CSS), DOM, accessibility
* **IANA** (Internet Assigned Numbers Authority): name and number registries
* **Ecma Intl.:** scripting standards, most prominently for JavaScript
* **ISO** (International Organization for Standardization): standards governing a diverse array of aspects, including character encodings, website management, and user-interface design
See also
--------
* Web standards on Wikipedia |
DOM (Document Object Model) - MDN Web Docs Glossary: Definitions of Web-related terms | DOM (Document Object Model)
===========================
The **DOM** (Document Object Model) is an API that represents and interacts with any HTML or XML-based markup language document. The DOM is a document model loaded in the browser and representing the document as a node tree, or **DOM tree**, where each node represents part of the document (e.g. an element, text string, or comment).
The DOM is one of the most-used APIs on the Web because it allows code running in a browser to access and interact with every node in the document. Nodes can be created, moved, and changed. Event listeners can be added to nodes and triggered on the occurrence of a given event.
See also
--------
* The DOM documentation on MDN
* The DOM Standard
* Document Object Model on Wikipedia |
Specification - MDN Web Docs Glossary: Definitions of Web-related terms | Specification
=============
A **specification** is a document that lays out in detail what functionality or attributes a product must include before delivery. In the context of describing the Web, the term "specification" (often shortened to "spec") generally means a document describing a language, technology, or API which makes up the complete set of open Web technologies.
See also
--------
* Specification on Wikipedia |
Dynamic typing - MDN Web Docs Glossary: Definitions of Web-related terms | Dynamic typing
==============
**Dynamically-typed languages** are those (like JavaScript) where the interpreter assigns variables a type at runtime based on the variable's value at the time.
See also
--------
* JavaScript data types and data structures
* Type system on Wikipedia |
Doctype - MDN Web Docs Glossary: Definitions of Web-related terms | Doctype
=======
In HTML, the doctype is the required "`<!DOCTYPE html>`" preamble found at the top of all documents. Its sole purpose is to prevent a browser from switching into so-called "quirks mode" when rendering a document; that is, the "`<!DOCTYPE html>`" doctype ensures that the browser makes a best-effort attempt at following the relevant specifications, rather than using a different rendering mode that is incompatible with some specifications.
See also
--------
* Definition of the DOCTYPE in the HTML specification
* Quirks Mode and Standards Mode
* Document.doctype, a JavaScript method that returns the doctype |
PHP - MDN Web Docs Glossary: Definitions of Web-related terms | PHP
===
PHP (a recursive initialism for PHP: Hypertext Preprocessor) is an open-source server-side scripting language that can be embedded into HTML to build web applications and dynamic websites.
Examples
--------
### Basic syntax
```php
// start of PHP code
<?php
// PHP code goes here
?>
// end of PHP code
```
### Printing data on screen
```php
<?php
echo "Hello World!";
?>
```
### PHP variables
```php
<?php
// variables
$nome='Danilo';
$sobrenome='Santos';
$pais='Brasil';
$email='danilocarsan@gmail.com';
// printing the variables
echo $nome;
echo $sobrenome;
echo $pais;
echo $email;
?>
```
See also
--------
* Official website
* PHP on Wikipedia
* PHP programming on Wikibooks
* MDN Web Docs Glossary
+ Java
+ JavaScript
+ Python
+ Ruby |
Trident - MDN Web Docs Glossary: Definitions of Web-related terms | Trident
=======
Trident (or MSHTML) was a layout engine that powered Internet Explorer. A Trident fork called *EdgeHTML* replaced Trident in Internet Explorer's successor, Edge.
See also
--------
* Trident layout engine on Wikipedia |
SMTP - MDN Web Docs Glossary: Definitions of Web-related terms | SMTP
====
**SMTP** (Simple Mail Transfer Protocol) is a protocol used to send a new email. Like POP and NNTP, it is a state machine-driven protocol.
The protocol is relatively straightforward. Primary complications include supporting various authentication mechanisms (GSSAPI, CRAM-MD5, NTLM, MSN, AUTH LOGIN, AUTH PLAIN, etc.), handling error responses, and falling back when authentication mechanisms fail (e.g., the server claims to support a mechanism, but doesn't).
See also
--------
* SMTP (Wikipedia)
* Glossary
+ NNTP
+ POP
+ protocol
+ state machine |
Falsy - MDN Web Docs Glossary: Definitions of Web-related terms | Falsy
=====
A **falsy** (sometimes written **falsey**) value is a value that is considered false when encountered in a Boolean context.
JavaScript uses type conversion to coerce any value to a Boolean in contexts that require it, such as conditionals and loops.
The following table provides a complete list of JavaScript falsy values:
| Value | Type | Description |
| --- | --- | --- |
| null | Null | The keyword `null` — the absence of any value. |
| undefined | Undefined | `undefined` — the primitive value. |
| `false` | Boolean | The keyword `false`. |
| NaN | Number | `NaN` — not a number. |
| `0` | Number | The `Number` zero, also including `0.0`, `0x0`, etc. |
| `-0` | Number | The `Number` negative zero, also including `-0.0`, `-0x0`, etc. |
| `0n` | BigInt | The `BigInt` zero, also including `0x0n`, etc. Note that there is no `BigInt` negative zero — the negation of `0n` is `0n`. |
| `""` | String | Empty string value, also including `''` and ````. |
| `document.all` | Object | The only falsy object in JavaScript is the built-in `document.all`. |
The values `null` and `undefined` are also nullish.
Examples
--------
Examples of *falsy* values in JavaScript (which are coerced to false in Boolean contexts, and thus *bypass* the `if` block):
```js
if (false) {
// Not reachable
}
if (null) {
// Not reachable
}
if (undefined) {
// Not reachable
}
if (0) {
// Not reachable
}
if (-0) {
// Not reachable
}
if (0n) {
// Not reachable
}
if (NaN) {
// Not reachable
}
if ("") {
// Not reachable
}
```
### The logical AND operator, &&
If the first object is falsy, it returns that object:
```js
console.log(false && "dog");
// ↪ false
console.log(0 && "dog");
// ↪ 0
```
See also
--------
* Truthy
* Coercion
* Boolean
* Boolean coercion |
Buffer - MDN Web Docs Glossary: Definitions of Web-related terms | Buffer
======
A buffer is a storage in physical memory used to temporarily store data while it is being transferred from one place to another.
See also
--------
* Data buffer on Wikipedia |
REST - MDN Web Docs Glossary: Definitions of Web-related terms | REST
====
**REST** (Representational State Transfer) refers to a group of software architecture design constraints that bring about efficient, reliable and scalable distributed systems.
The basic idea of REST is that a resource, e.g. a document, is transferred via well-recognized, language-agnostic, and reliably standardized client/server interactions. Services are deemed RESTful when they adhere to these constraints.
HTTP APIs in general are sometimes colloquially referred to as RESTful APIs, RESTful services, or REST services, although they don't necessarily adhere to all REST constraints. Beginners can assume a REST API means an HTTP service that can be called using standard web libraries and tools.
See also
--------
* restapitutorial.com
* restcookbook.com
* REST on Wikipedia
* REST Architecture |
Decryption - MDN Web Docs Glossary: Definitions of Web-related terms | Decryption
==========
In cryptography, **decryption** is the conversion of ciphertext into Plaintext.
Decryption is a cryptographic primitive: it transforms a ciphertext message into plaintext using a cryptographic algorithm called a cipher. Like encryption, decryption in modern ciphers is performed using a specific algorithm and a secret, called the key. Since the algorithm is often public, the key must stay secret if the encryption stays secure.
Decryption is the reverse of encryption and if the key stays secret, decryption without knowing the specific secret, decryption is mathematically hard to perform. How hard depends on the security of the cryptographic algorithm chosen and evolves with the progress of cryptanalysis.
See also
--------
* Encryption and Decryption |
Java - MDN Web Docs Glossary: Definitions of Web-related terms | Java
====
Java is a compiled, object-oriented, highly portable programming language.
Java is statically typed and features a similar syntax to C. It comes with a large library of readily usable functions, the Java Software Development Kit (SDK).
Programs are compiled only once ahead of time into a proprietary byte code and package format that runs inside the Java Virtual Machine (JVM). The JVM is available across many platforms, which allows Java programs to run almost everywhere without the need to be compiled or packaged again. This makes it a preferred language in many large enterprises with heterogeneous landscapes, but may be perceived "heavy".
See also
--------
* Java on Wikipedia |
Blink - MDN Web Docs Glossary: Definitions of Web-related terms | Blink
=====
Blink is an open-source browser layout engine developed by Google as part of Chromium (and therefore part of Chrome as well). Specifically, Blink began as a fork of the WebCore library in WebKit, which handles layout, rendering, and DOM, but now stands on its own as a separate rendering engine.
See also
--------
* Blink project home page
* Blink on Wikipedia
* FAQ on Blink
* Glossary
+ Google Chrome
+ Gecko
+ Trident
+ WebKit
+ Rendering engine |
Middleware - MDN Web Docs Glossary: Definitions of Web-related terms | Middleware
==========
Middleware is a (loosely defined) term for any software or service that enables the parts of a system to communicate and manage data. It is the software that handles communication between components and input/output, so developers can focus on the specific purpose of their application.
In server-side web application frameworks, the term is often more specifically used to refer to pre-built software components that can be added to the framework's request/response processing pipeline, to handle tasks such as database access.
See also
--------
* Middleware\_(distributed\_applications) on Wikipedia
* Middleware on Wikipedia |
Idempotent - MDN Web Docs Glossary: Definitions of Web-related terms | Idempotent
==========
An HTTP method is **idempotent** if the intended effect on the server of making a single request is the same as the effect of making several identical requests.
This does not necessarily mean that the request does not have *any* unique side effects: for example, the server may log every request with the time it was received. Idempotency only applies to effects intended by the client: for example, a POST request intends to send data to the server, or a DELETE request intends to delete a resource on the server.
All safe methods are idempotent, as well as `PUT` and `DELETE`. The `POST` method is not idempotent.
To be idempotent, only the state of the server is considered. The response returned by each request may differ: for example, the first call of a `DELETE` will likely return a `200`, while successive ones will likely return a `404`. Another implication of `DELETE` being idempotent is that developers should not implement RESTful APIs with a *delete last entry* functionality using the `DELETE` method.
Note that the idempotence of a method is not guaranteed by the server and some applications may incorrectly break the idempotence constraint.
`GET /pageX HTTP/1.1` is idempotent, because it is a safe (read-only) method. Successive calls may return different data to the client, if the data on the server was updated in the meantime.
`POST /add_row HTTP/1.1` is not idempotent; if it is called several times, it adds several rows:
```http
POST /add\_row HTTP/1.1
POST /add\_row HTTP/1.1 -> Adds a 2nd row
POST /add\_row HTTP/1.1 -> Adds a 3rd row
```
`DELETE /idX/delete HTTP/1.1` is idempotent, even if the returned status code may change between requests:
```http
DELETE /idX/delete HTTP/1.1 -> Returns 200 if idX exists
DELETE /idX/delete HTTP/1.1 -> Returns 404 as it just got deleted
DELETE /idX/delete HTTP/1.1 -> Returns 404
```
See also
--------
* Definition of idempotent in the HTTP specification.
* Description of common idempotent methods: `GET`, `HEAD`, `PUT`, `DELETE`, `OPTIONS`, `TRACE`
* Description of common non-idempotent methods: `POST`, `PATCH`, `CONNECT` |
Tag - MDN Web Docs Glossary: Definitions of Web-related terms | Tag
===
In HTML, a **tag** is used for creating an element.
The name of an HTML element is the name that appears at the beginning of the element's start tag and at the end of the element's end tag (if the element has an end tag). For example, the `p` in the `<p>` start tag and `</p>` end tag is the name of the HTML paragraph element. Note that an element name in an end tag is preceded by a slash character: `</p>`, and that for void elements, the end tag is neither required nor allowed.
See also
--------
* HTML element on Wikipedia
* HTML elements syntax on WHATWG
* Introduction to HTML |
Array - MDN Web Docs Glossary: Definitions of Web-related terms | Array
=====
An *array* is an ordered collection of data (either primitive or object depending upon the language). Arrays are used to store multiple values under a single variable name. A regular variable, on the other hand, can store only one value.
Each item in an array has a number attached to it, called a numeric index, that allows you to access it. In JavaScript, arrays start at index zero and can be manipulated with various methods.
Arrays in JavaScript look like this:
```js
// Arrays in JavaScript can hold different types of data
const myArray = [1, 2, 3, 4];
const barbieDollNamesArray = ["Barbie", "Ken", "Midge", "Allan", "Skipper"];
// Array indexes starts at 0.
console.log(myArray[0]); // output: 1
console.log(barbieDollNamesArray[2]); // output: "Midge"
```
See also
--------
* JavaScript `Array` on MDN |
ITU - MDN Web Docs Glossary: Definitions of Web-related terms | ITU
===
The International Telecommunication Union (ITU) is the organization authorized by the United Nations to establish standards and rules for telecommunication, including telegraph, radio, telephony and the internet.
From defining rules for ensuring transmissions get to where they need to go to and creating the "SOS" alert signal used in Morse code, the ITU has long played a key role in how we use technology to exchange information and ideas.
In the Internet Age, the ITU's role of establishing standards for video and audio data formats used for streaming, teleconferencing, and other purposes. For example, the ITU and the Moving Picture Experts Group (MPEG) worked together to develop and publish, as well as to maintain, the various MPEG specifications, such as MPEG-2 (ITU H.262), AVC (ITU H.264), and HEVC (ITU H.265).
See also
--------
* ITU website
* ITU history portal |
Class - MDN Web Docs Glossary: Definitions of Web-related terms | Class
=====
In object-oriented programming, a *class* defines an object's characteristics. Class is a template definition of an object's properties and methods, the "blueprint" from which other more specific instances of the object are drawn.
See also
--------
* Classes in JavaScript
* Inheritance and the prototype chain
* Class-based programming on Wikipedia
* Object-oriented programming on Wikipedia |
Table Grid Box - MDN Web Docs Glossary: Definitions of Web-related terms | Table Grid Box
==============
The **Table Grid Box** is a block level box which contains all of the table internal boxes, excluding the caption. The box which includes the caption is referred to as the Table Wrapper Box. |
Stringifier - MDN Web Docs Glossary: Definitions of Web-related terms | Stringifier
===========
An object's stringifier is any attribute or method that is defined to provide a textual representation of the object for use in situations where a string is expected.
See also
--------
* Stringifiers in Information contained in a WebIDL file |
UUID - MDN Web Docs Glossary: Definitions of Web-related terms | UUID
====
A **Universally Unique Identifier** (**UUID**) is a label used to uniquely identify a resource among all other resources of that type.
Computer systems generate UUIDs locally using very large random numbers.
In theory the IDs may not be globally unique, but the probability of duplicates is vanishingly small.
If systems really need absolutely unique IDs then these might be allocated by a central authority.
UUIDs are 128-bit values that are canonically represented as a 36-character string in the format `123e4567-e89b-12d3-a456-426614174000` (5 hex strings separated by hyphens).
There are a number of versions that differ slightly in the way they are calculated; for example, the inclusion of temporal information.
The formal definition can be found in: RFC4122: A Universally Unique IDentifier (UUID) URN Namespace.
See also
--------
* UUID on Wikipedia
* `Crypto.randomUUID()` |
Hyperlink - MDN Web Docs Glossary: Definitions of Web-related terms | Hyperlink
=========
Hyperlinks connect webpages or data items to one another. In HTML, `<a>` elements define hyperlinks from a spot on a webpage (like a text string or image) to another spot on some other webpage (or even on the same page).
See also
--------
* Hyperlink on Wikipedia
* The Hyperlink guide on MDN
* Links in HTML Documents - W3C
* HTML a - hyperlink - W3C
* `<a>` on MDN
* `<link>` on MDN |
Truthy - MDN Web Docs Glossary: Definitions of Web-related terms | Truthy
======
In JavaScript, a **truthy** value is a value that is considered `true` when encountered in a Boolean context. All values are truthy unless they are defined as falsy. That is, all values are *truthy* except `false`, `0`, `-0`, `0n`, `""`, `null`, `undefined`, `NaN`, and `document.all`.
JavaScript uses type coercion in Boolean contexts.
Examples of *truthy* values in JavaScript (which will be coerced to `true` in boolean contexts, and thus execute the `if` block):
```js
if (true)
if ({})
if ([])
if (42)
if ("0")
if ("false")
if (new Date())
if (-42)
if (12n)
if (3.14)
if (-3.14)
if (Infinity)
if (-Infinity)
```
### The logical AND operator, &&
If the first operand is truthy, the logical AND operator returns the second operand:
```js
true && "dog"
// returns "dog"
[] && "dog"
// returns "dog"
```
See also
--------
* Falsy
* Type coercion
* Boolean
* Boolean coercion |
WAI - MDN Web Docs Glossary: Definitions of Web-related terms | WAI
===
WAI or Web Accessibility Initiative is an effort by the World Wide Web Consortium (W3C) to improve accessibility for people with various challenges, who may need a nonstandard browser or devices.
See also
--------
* WAI website
* Web Accessibility Initiative on Wikipedia |
Opera Browser - MDN Web Docs Glossary: Definitions of Web-related terms | Opera Browser
=============
**Opera** is the fifth most used web browser, publicly released in 1996 and initially running on Windows only. Opera uses Blink as its layout engine since 2013 (before that, Presto). Opera also exists in mobile and tablet versions.
See also
--------
* Opera Browser on Wikipedia
* Opera browser website |
XInclude - MDN Web Docs Glossary: Definitions of Web-related terms | XInclude
========
XInclude is a W3C Recommendation defining inclusion tags that enable documents to include other documents or parts of other documents. Content can be included from other XML files or from text files.
The XInclude mechanism is not supported natively by any major browsers.
See also
--------
* XInclude standard
* `XPath` |
Real User Monitoring (RUM) - MDN Web Docs Glossary: Definitions of Web-related terms | Real User Monitoring (RUM)
==========================
**Real User Monitoring** or RUM measures the performance of a page from real users' machines. Generally, a third party script injects a script on each page to measure and report page load data for every request made. This technique monitors an application's actual user interactions. In RUM, the third party script collects performance metrics from the real users' browsers. RUM helps identify how an application is being used, including the geographic distribution of users and the impact of that distribution on the end user experience.
See also
--------
* Real User Monitoring (RUM) versus Synthetic Monitoring
* Synthetic Monitoring
* Beacon |
First-class Function - MDN Web Docs Glossary: Definitions of Web-related terms | First-class Function
====================
A programming language is said to have **First-class functions** when functions in that language are treated like any other variable. For example, in such a language, a function can be passed as an argument to other functions, can be returned by another function and can be assigned as a value to a variable.
Examples
--------
### Assigning a function to a variable
```js
const foo = () => {
console.log("foobar");
};
foo(); // Invoke it using the variable
// foobar
```
We assigned an *Anonymous Function* in a Variable, then we used that variable to invoke the function by adding parentheses `()` at the end.
**Note:** Even if your function was named, you can use the variable name to invoke it. Naming it will be helpful when debugging your code. *But it won't affect the way we invoke it.*
### Passing a function as an argument
```js
function sayHello() {
return "Hello, ";
}
function greeting(helloMessage, name) {
console.log(helloMessage() + name);
}
// Pass `sayHello` as an argument to `greeting` function
greeting(sayHello, "JavaScript!");
// Hello, JavaScript!
```
We are passing our `sayHello()` function as an argument to the `greeting()` function, this explains how we are treating the function as a value.
**Note:** The function that we pass as an argument to another function is called a *callback function*. *`sayHello()` is a callback function.*
### Returning a function
```js
function sayHello() {
return () => {
console.log("Hello!");
};
}
```
In this example, we are returning a function from another function - *We can return a function because functions in JavaScript are treated as values.*
**Note:** A function that returns a function or takes other functions as arguments is called a *higher-order function*.
See also
--------
* First-class functions on Wikipedia
* MDN Web Docs Glossary
+ Callback function
+ Function
+ Variable |
Fallback alignment - MDN Web Docs Glossary: Definitions of Web-related terms | Fallback alignment
==================
In CSS Box Alignment, a fallback alignment is specified in order to deal with cases where the requested alignment cannot be fulfilled. For example, if you specify `justify-content: space-between` there must be more than one alignment subject. If there is not, the fallback alignment is used. This is specified per alignment method, as detailed below.
First baseline
`start`
Last baseline
`safe end`
Baseline
`start`
Space-between
`flex-start` (start)
Space-around
`center`
Space-evenly
`center`
Stretch
`flex-start` (start)
See also
--------
* CSS Box Alignment |
Cryptographic hash function - MDN Web Docs Glossary: Definitions of Web-related terms | Cryptographic hash function
===========================
A cryptographic hash function, also sometimes called a *digest function*, is a cryptographic primitive transforming a message of arbitrary size into a message of fixed size, called a digest. Cryptographic hash functions are used for authentication, digital signatures, and message authentication codes.
To be used for cryptography, a hash function must have these qualities:
* quick to compute (because they are generated frequently)
* not invertible (each digest could come from a very large number of messages, and only brute-force can generate a message that leads to a given digest)
* tamper-resistant (any change to a message leads to a different digest)
* collision-resistant (it should be impossible to find two different messages that produce the same digest)
Cryptographic hash functions such as MD5 and SHA-1 are considered broken, as attacks have been found that significantly reduce their collision resistance.
See also
--------
* Cryptographic hash function on Wikipedia
* MDN Web Docs Glossary
+ Symmetric-key cryptography |
Literal - MDN Web Docs Glossary: Definitions of Web-related terms | Literal
=======
**Literals** represent values in JavaScript. These are fixed values—not variables—that you *literally* provide in your script.
* Array literals
* Boolean literals
* Floating-point literals
* Numeric literals
* Object literals
* RegExp literals
* String literals
Examples
--------
### String literals
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 both double quotation marks).
The following are examples of string literals:
```js
"foo";
"bar";
"1234";
"one line \n new line";
"Joyo's cat";
```
### Object literals
An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces (`{}`).
The following is an example of an object literal. The first element of the `car` object defines a property, `myCar`, and assigns to it a new string, "`Toyota`"; the second element, the `getCar` property, is immediately assigned the result of invoking the function `carTypes('Honda')`; the third element, the `special` property, uses an existing variable (`sales`).
```js
const sales = "BMW";
function carTypes(name) {
return name === "Honda" ? name : `Sorry, we don't sell ${name}.`;
}
const car = {
myCar: "Toyota",
getCar: carTypes("Honda"),
special: sales,
};
console.log(car.myCar); // Toyota
console.log(car.getCar); // Honda
console.log(car.special); // BMW
```
See also
--------
* Literal on Wikipedia |
Random Number Generator - MDN Web Docs Glossary: Definitions of Web-related terms | Random Number Generator
=======================
A **PRNG** (pseudorandom number generator) is an algorithm that outputs numbers in a complex, seemingly unpredictable pattern. Truly random numbers (say, from a radioactive source) are utterly unpredictable, whereas all algorithms are predictable, and a PRNG returns the same numbers when passed the same starting parameters or *seed*.
PRNGs can be used for a variety of applications, such as games.
A cryptographically secure PRNG is a PRNG with certain extra properties making it suitable for use in cryptography. These include:
* that it's computationally unfeasible for an attacker (without knowledge of the seed) to predict its output
* that if an attacker can work out its current state, this should not enable the attacker to work out previously emitted numbers.
Most PRNGs are not cryptographically secure.
See also
--------
* Pseudorandom number generator on Wikipedia
* `Math.random()`, a built-in JavaScript PRNG function. Note that this is not a cryptographically secure PRNG.
* `Crypto.getRandomValues()`: this is intended to provide cryptographically secure numbers. |
Grid Axis - MDN Web Docs Glossary: Definitions of Web-related terms | Grid Axis
=========
CSS Grid Layout is a two-dimensional layout method enabling the laying out of content in *rows* and *columns*. Therefore in any grid we have two axes. The *block or column axis*, and the *inline or row axis*.
It is along these axes that items can be aligned and justified using the properties defined in the Box Alignment specification.
In CSS the *block or column axis* is the axis used when laying out blocks of text. If you have two paragraphs and are working in a right to left, top to bottom language they lay out one below the other, on the block axis.
The *inline or row axis* runs across the Block Axis and is the direction along which regular text flows. These are our rows in CSS Grid Layout.
The physical direction of these axes can change according to the writing mode of the document.
See also
--------
* CSS Grid Layout Guide: *Basic concepts of grid layout*
* CSS Grid Layout Guide: *Box alignment in Grid Layout*
* CSS Grid Layout Guide: *Grids, logical values and writing modes* |
Selector (CSS) - MDN Web Docs Glossary: Definitions of Web-related terms | Selector (CSS)
==============
A **CSS selector** is the part of a CSS rule that describes what elements in a document the rule will match. The matching elements will have the rule's specified style applied to them.
Example
-------
Consider this CSS:
```css
p {
color: green;
}
div.warning {
width: 100%;
border: 2px solid yellow;
color: white;
background-color: darkred;
padding: 0.8em 0.8em 0.6em;
}
#customized {
font:
16px Lucida Grande,
Arial,
Helvetica,
sans-serif;
}
```
The selectors here are `"p"` (which applies the color green to the text inside any `<p>` element), `"div.warning"` (which makes any `<div>` element with the class `"warning"` look like a warning box), and `"#customized"`, which sets the base font of the element with the ID `"customized"` to 16-pixel tall Lucida Grande or one of a few fallback fonts.
We can then apply this CSS to some HTML, such as:
```html
<p>This is happy text.</p>
<div class="warning">
Be careful! There are wizards present, and they are quick to anger!
</div>
<div id="customized">
<p>This is happy text.</p>
<div class="warning">
Be careful! There are wizards present, and they are quick to anger!
</div>
</div>
```
The resulting page content is styled like this:
See also
--------
* Learn more about CSS selectors in our introduction to CSS.
* Basic selectors
+ Type selectors `elementname`
+ Class selectors `.classname`
+ ID selectors `#idname`
+ Universal selectors `* ns|* *|*`
+ Attribute selectors `[attr=value]`
+ State selectors `a:active, a:visited`
* Grouping selectors
+ Selector list `A, B`
* Combinators
+ Next-sibling selectors `A + B`
+ Subsequent-sibling selectors `A ~ B`
+ Child selectors `A > B`
+ Descendant selectors `A B`
* Pseudo
+ Pseudo classes `:`
+ Pseudo elements `::` |
Mobile First - MDN Web Docs Glossary: Definitions of Web-related terms | Mobile First
============
**Mobile first**, a form of progressive enhancement, is a web-development and web-design approach that focuses on prioritizing design and development for mobile screen sizes over design and development for desktop screen sizes. The rationale behind the mobile-first approach is to provide users with good user experiences at all screen sizes—by starting with creating a user experience that works well on small screens, and then building on top of that to further enrich the user experience as the screen size increases. The mobile-first approach contrasts with the older approach of designing for desktop screen sizes first, and then only later adding some support for small screen sizes. |
Character set - MDN Web Docs Glossary: Definitions of Web-related terms | Character set
=============
A **character set** is an encoding system to let computers know how to recognize Character, including letters, numbers, punctuation marks, and whitespace.
In earlier times, countries developed their own character sets due to their different languages used, such as Kanji JIS codes (e.g. Shift-JIS, EUC-JP, etc.) for Japanese, Big5 for traditional Chinese, and KOI8-R for Russian. However, Unicode gradually became most acceptable character set for its universal language support.
If a character set is used incorrectly (For example, Unicode for an article encoded in Big5), you may see nothing but broken characters, which are called Mojibake.
See also
--------
* Character encoding (Wikipedia)
* Mojibake (Wikipedia)
* Glossary
+ Character
+ Unicode |
Main Axis - MDN Web Docs Glossary: Definitions of Web-related terms | Main Axis
=========
The main axis in flexbox is defined by the direction set by the `flex-direction` property. There are four possible values for `flex-direction`. These are:
* `row`
* `row-reverse`
* `column`
* `column-reverse`
Should you choose `row` or `row-reverse` then your main axis will run along the row in the inline direction.
Choose `column` or `column-reverse` and your main axis will run top to bottom of the page in the block direction.
On the main axis you can control the sizing of flex items by adding any available space to the items themselves, by way of `flex` properties on the items. Or, you can control the space between and around items by using the `justify-content` property.
See also
--------
### Property reference
* `flex-basis`
* `flex-direction`
* `flex-grow`
* `flex-shrink`
* `justify-content`
* `flex`
### Further reading
* CSS Flexbox Guide:
+ Basic Concepts of Flexbox
+ Aligning items in a flex container
+ Controlling Ratios of flex items along the main axis |
Resource Timing - MDN Web Docs Glossary: Definitions of Web-related terms | Resource Timing
===============
Diagnosing performance issues requires performance data at the granularity of the resource. The Resource Timing API is a JavaScript API that is able to capture timing information for each individual resource that is fetched when a page is loaded.
See also
--------
* Using the resource timing API
* Server Timing |
SLD - MDN Web Docs Glossary: Definitions of Web-related terms | SLD
===
An SLD (Second Level Domain) is the part of the domain name that is located right before a *Top Level Domain* (TLD). For example, in `mozilla.org` the SLD is `mozilla` and the TLD is `org`.
See Second Level Domain for more information. |
Domain sharding - MDN Web Docs Glossary: Definitions of Web-related terms | Domain sharding
===============
Browsers limit the number of active connections for each domain. To enable concurrent downloads of assets exceeding that limit, **domain sharding** splits content across multiple subdomains. When multiple domains are used to serve multiple assets, browsers are able to download more resources simultaneously, resulting in a faster page load time and improved user experience.
The problem with domain sharding, in terms of performance, is the cost of extra DNS lookups for each domain and the overhead of establishing each TCP connection.
The initial response from an HTTP request is generally an HTML file listing other resources such as JavaScript, CSS, images and other media files that need to be downloaded. As browsers limit the number of active connections per domain, serving all the required resources from a single domain could be slow as assets need to be downloaded sequentially. With domain sharding, the required downloads are served from more than one domain, enabling the browser to simultaneously download needed resources. Multiple domains, however, is an anti-pattern, as DNS lookups slow initial load times.
HTTP2 supports unlimited concurrent requests making domain sharding an obsolete requirement when HTTP/2 is enabled.
See also
--------
* TLS
* DNS
* HTTP/2 |
SIMD - MDN Web Docs Glossary: Definitions of Web-related terms | SIMD
====
SIMD (pronounced "sim-dee") is short for **Single Instruction/Multiple Data** which is one classification of computer architectures. SIMD allows one same operation to be performed on multiple data points resulting in data level parallelism and thus performance gains — for example, for 3D graphics and video processing, physics simulations or cryptography, and other domains.
See also SISD for a sequential architecture with no parallelism in either the instructions or the data sets.
See also
--------
* SIMD on Wikipedia
* Glossary
+ SIMD
+ SISD |
Alpha (alpha channel) - MDN Web Docs Glossary: Definitions of Web-related terms | Alpha (alpha channel)
=====================
The **alpha channel** specifies to opacity of a (`<color>`). Colors are represented in digital form as a collection of numbers, each representing the strength or intensity level of a given component of the color. Each of these components is called a **channel**. In a typical image file, the color channels describe how much red, green, and blue are used to make up the final color. To represent a color through which the background can be seen to some extent, a fourth channel is added to the color: the alpha channel.
For example, the color `#8921F2` (also described as `rgb(137 33 242)` or `hsl(270 89% 54)`) is a nice shade of purple. Below you see a small box of that color in the top-left corner and a box of the *same* color but with an alpha channel set at 50% (or 0.5) opacity, `#8921F280`, where `80` is the hexadecimal equivalent of 50%. This color is also described as `rgb(137 33 242 / 50%)` or `hsl(270 89% 54 / 50%)`. The two boxes are drawn on top of a paragraph of text.
As you can see, the color without an alpha channel completely blocks the background text, while the box with the alpha channel leaves it visible through the purple background color.
See also
--------
* CSS colors
* CSS values and units introduction
* Image file type and format guide
* Alpha compositing on Wikipedia
* RGBA color model on Wikipedia
* Channel (digital image) on Wikipedia |
Code splitting - MDN Web Docs Glossary: Definitions of Web-related terms | Code splitting
==============
**Code splitting** is the practice of splitting the code a web application depends on — including its own code and any third-party dependencies — into separate bundles that can be loaded independently of each other.
This allows an application to load only the code it actually needs at a given point in time, and load other bundles on demand.
This approach is used to improve application performance, especially on initial load.
Code splitting is a feature supported by bundlers like Webpack and Browserify which can create multiple bundles that can be dynamically loaded at runtime.
See also
--------
* Bundling
* Lazy loading
* HTTP/2
* Tree shaking |
OpenGL - MDN Web Docs Glossary: Definitions of Web-related terms | OpenGL
======
**OpenGL** (**Open Graphics Library**) is a cross-language, multi-platform application programming interface (API) for rendering 2D and 3D vector graphics. The API is typically used to interact with a graphics processing unit (GPU), to achieve hardware-accelerated rendering.
See also
--------
* OpenGL on Wikipedia
* OpenGL |
Locale - MDN Web Docs Glossary: Definitions of Web-related terms | Locale
======
**Locale** is a set of language- or country-based preferences for a user interface.
A program draws its locale settings from the language of the host system. Among other things, locales represent paper format, currency, date format, and numbers according to the protocols in the given region.
See also
--------
* Locale on Wikipedia |