Glossary – Useful Definitions of Web-related Terms
A
Absolute length units
Absolute length units are fixed standards of measurement. In other words, the size of things expressed in any of the absolute length units will never change—regardless of the medium used to display them.
Aggregator file (ES Module)
An aggregator file is a script used solely to import and re-export the items you've exported from other modules.
Anchor (RegExp)
Regular expression's anchor operators assert the precise location in a string where you wish to find a RegExp pattern.
Anchor (URL)
An anchor is a link to a specific part of the same file the URL references.
AND operator (JS)
The AND operator (&&) checks if all of its operands are true.
Annotation
Annotations (markup) are notes that get added to texts. So, for instance, HTML is an annotation language developers use to describe a web document.
Some other popular markup languages are XML, Markdown, SVG, Keyhole, MathML, X3D, XHTML, and LaTeX.
Anonymous function
An anonymous function is a function that has no name.
apply()
apply() is one of JavaScript's built-in methods that you can use to reassign a specific method from one object to a different one.
Argument (JS)
An argument is an optional value you may pass to a function's parameter through an invocator.
arguments object (JS)
An arguments object is an array-like object built-in to every non-arrow function.
Arithmetic expression (JS)
An arithmetic expression is a piece of code that expresses a numeric value.
Array (JS)
An array object is an element used to bundle multiple unnamed values into a single item.
Array destructuring (JS)
Array destructuring is a unique technique you can use to copy an array's value into new variables neatly.
Array-like object (JS)
An array-like object is an object that has only a few—not all—of the features of a regular JavaScript array.
Arrow function expression (JS)
An arrow function expression is a shorthand way to write a function expression.
Assertions (RegExp)
Regular expression's assertions operator asserts the precise location in a string where you wish to find a RegExp pattern.
Assignment expression (JS)
An assignment expression is any piece of code that assigns its evaluated value to a variable (or property).
ASYNC (asynchronous)
ASYNC (asynchronous) means "not synchronous".
Asynchronous callback
An asynchronous callback is a callback whose invocation occurs in the future.
Asynchronous event
An asynchronous event is a program that can happen at any convenient time.
An asynchronous event does not wait for another event to complete its processing before starting its own execution.
Asynchronous function
An asynchronous function is a function that runs in its own timing—without waiting for another function to finish its execution first.
At least one (RegExp)
Regular expression's at least one operator (+) specifies that you wish to find at least one consecutive occurrence of its preceding item.
Audio data
Audio data are the sound-recorded contents of a page, such as WAV, MP3, and AAC.
B
Base case
A base case is a code written to discontinue the re-invocation of a recursive function.
BigInt (JS)
BigInt is a unique numeric data type used mainly for arbitrarily lengthy integers.
bind()
bind() is one of JavaScript's built-in methods that you can use to reassign a specific method from one object to a different one.
Blocking (JavaScript)
Blocking is a term used to refer to the spinning cursor moments (when the browser appears frozen). In such a period, the currently running operation blocks the browser from doing other things until it has finished its execution.
Boolean (JS)
Boolean states the falseness or truthfulness of an expression (or variable).
Bracketed expression
A bracketed expression is an expression placed inside a pair of square brackets.
Here's an example:
// Initialize a num variable with a number:
let num = 0;
// Assign a string value to an enSuites variable:
const enSuites = "East";
// Define a doorNo object and compute each of its properties' names:
const doorNo = {
[enSuites + ++num]: num,
[enSuites + ++num]: num,
[enSuites + ++num]: num,
};
// Check the doorNo's content:
console.log(doorNo);
// The invocation above will return:
{East1: 1, East2: 2, East3: 3}
In the JavaScript snippet above, enSuites + ++num is a bracketed expression because it is an expression placed inside a pair of square brackets.
Bracketed string
A bracketed string is a string value placed inside a pair of square brackets.
Here's an example:
// Define a properties object:
const manager = { firstName: "Jonny", son: "Paul", wife: "Beauty" };
// Define a variable:
const wife = "son";
// Invoke the manager object's wife property:
manager["wife"];
// The invocation above will return: "Beauty"
In the JavaScript snippet above, "wife" is a bracketed string because it is a string value placed inside a pair of square brackets.
Bracketed variable
A bracketed variable is a variable placed inside a pair of square brackets.
Here's an example:
// Define a properties object:
const manager = { firstName: "Jonny", son: "Paul", wife: "Beauty" };
// Define a variable:
const wife = "son";
// Invoke the wife variable's value inside the manager object:
manager[wife];
// The invocation above will return: "Paul"
In the JavaScript snippet above, wife is a bracketed variable because it is a variable placed inside a pair of square brackets.
Browser
A browser is a software application used to view a website's content.
In other words, browsers are like digital showcase containers for displaying billions of resources.
Tourists look at a showcase of a jewelry store – Image by Egor Myznik
Mozilla Firefox, Google Chrome, Opera, and Microsoft Edge are commonly used browsers.
note
- Browsers are sometimes called web browsers or internet browsers.
- Technically, a browser is a type of client (also called a software program) used by computers to request and receive data from another software (computer).
- Email clients, Window Desktop Client, and Postman are other client types that computers can use to request and receive data from other software.
Build step
A build step is a process through which a module bundler builds a new browser compatible JavaScript file.
C
call()
call() is one of JavaScript's built-in methods that you can use to reassign a specific method from one object to a different one.
Call-after (JavaScript)
A call-after is a function A passed as an argument into a function B and invoked inside function B.
Callback (JavaScript)
A callback is a function A passed as an argument into a function B and invoked inside function B.
Calling array (JS)
A calling array is an array on which you used methods like map(), filter(), or slice().
Calling string (JS)
A calling string is a string on which you used methods like replace() or matchAll().
Capturing group (RegExp)
A regular expression's capturing group operator ((...)) groups zero or more patterns.
Caret (RegExp)
A regular expression's caret operator ([^abc]) defines the set of characters you do not wish to find in a single character's position.
Chained conditional operator (JS)
A chained conditional operator is an alternate (shortcut) way of writing an if...else if...else statement.
Chained question mark operator (JS)
A chained question mark operator is an alternate (shortcut) way of writing an if...else if...else statement.
Chained ternary operator (JS)
A chained ternary operator is an alternate (shortcut) way of writing an if...else if...else statement.
Character classes (RegExp)
Regular expression's character classes are operators used to specify the precise type of characters you wish to find in a specific string.
Character set (RegExp)
A regular expression's character set ([abc]) defines the set of characters you wish to find in a single character's position.
Chunk
A chunk refers to the modified section of a file.
A chunk consists of the modified line and its context, where context means some unaltered lines before and after the modified line.
Class component
A class component is a plain JavaScript Class that extends a user-defined class to the built-in React.Component class located inside the React library.
Code
Code is any language that computers can understand and process.
Code block
A block is a pair of braces ({...}) used to group multiple statements.
Computed Property Names
Computed Property Names refer to the name of a property that the computer derived by computing (evaluating) a bracketed expression.
Concatenation
Concatenation means to join two or more things together. For instance, string concatenation implies the joining together of two or more strings.
Conditional operator (JS)
A conditional operator is an alternate (shortcut) way of writing an if...else statement.
Conditional statement (JS)
A conditional statement is any code used to specify the prerequisites necessary for the computer to perform specific actions.
Configuration file (Webpack)
Webpack's configuration file is a JavaScript file that allows you to modify or extend webpack's default settings.
Controlled component (ReactJS)
A controlled component is a component whose form's data React controls exclusively.
Create React App
Create React App (CRA) is an official React package used to set up React projects easily without going through the troubles of configuring build tools like Webpack or Babel.
CSS
CSS (Cascading Style Sheets) is a styling language that styles elements of an HTML document.
CSS unit
A CSS Unit is the standard of measurement used in CSS to express the size of a specific element's property.
D
Data
Data is the content of a document. In order words, the text and graphics on a page are the document's data.
Data types (JS)
JavaScript data types refer to the kind of values you can assign to JavaScript variables.
Declaration
Declaration means to declare the creation of variables and functions.
Declaration statement (JS)
A declaration statement is a piece of code that declares the creation of variables and functions.
Deep copy (JS)
You do deep copy when you clone objects without creating references.
Deep object (JS)
A deep object is one that contains a non-primitive item.
Default export (ES Modules)
Default export is a technique developers use to export code anonymously (namelessly).
Default parameter (JS)
JavaScript's default parameters provide a way to initialize your function's parameter with a default value.
Dependency
A dependency is a file your script requires to work as intended. So, in import { variable } from "./path/to/module.js", module.js is the dependency file because it is a script our app depends on to function as designed.
Destructuring assignment (JS)
The destructuring assignment is a unique technique you can use to copy the values of an object or array into new variables.
Distribution code
A distribution code is the minified and optimized version of the source code.
In other words, a distribution code (the build step's output) refers to the JavaScript file a bundler generates automatically for your project.
DNS Hierarchy
DNS Hierarchy is a system used to sort the parts of a domain name according to their importance.
do…while loop statement (JS)
A do...while loop instructs the computer to do the task in the code block once. Then, while the specified condition is true, it should repeat the block's execution.
Document
A document is a page used to contain text, or graphics, or both.
Domain name
A domain name is a website's name.
Domain Name Server
A Domain Name Server (DNS) is the server (or computer) used to store domain names and their corresponding IP addresses.
note
- Domain name servers are sometimes called nameservers or DNS servers.
- IP addresses typically have two nameservers.
- You can use ICANN's lookup tool to get a website's nameservers and other domain information.
Domain Name System
A Domain Name System (DNS) is the system (technique) by which domain names get converted to their equivalent IP (Internet Protocol) addresses.
Dot (RegExp)
Regular expression's dot operator (.) specifies that you wish to find any character that is not the newline or any other line terminator characters.
Dot all (RegExp)
Regular expression's dot all flag (s) tells the computer to allow a wildcard operator (.) to match all characters—including a newline character.
Dummy (TDD)
A dummy is a test double used to mimic the value of a specific dependency.
E
Editing platform
An editing platform (IDE) is the app used by editors (developers) to prepare documents for publication.
Popular editing platforms used by most software developers are Sublime Text, Visual Studio, Atom, and Brackets.
Editor
An editor is a person that edits a software document.
Effect hook (ReactJS)
The effect hook (useEffect) allows a function component to hook into React's lifecycle features for performing side effects.
else conditional statement (JS)
The else conditional statement instructs that if the if statement's condition is false, the computer should execute the else statement's code block.
else if conditional statement (JS)
The else if conditional statement instructs the computer that if the if statement's condition is false, JavaScript should execute the else if's code block based on a different condition.
End of (RegExp)
Regular expression's end of operator ($) asserts that you wish to find the RegExp pattern at the end of a string.
End-to-End test (TDD)
An End-to-End (E2E) test is a test written to assess the functionality of a user interface.
Entry point
An entry point is a file that a bundler uses to start building a dependency graph of all the project's modules it needs to combine into a single browser-compatible module.
An entry point is the most critical file of a build step that links (directly or indirectly) to every other module in a project.
Equality operator (JS)
The equality operator (==) checks if its two operands are of equal value.
Error handling phase (ReactJS)
A component's error handling phase is the period when an error occurs in any of the following cases:
- During the component instance's rendering
- In a lifecycle method of the component
- In any child component's constructor
Error handling statement (JS)
An error handling statement is a piece of code that allows you to test, manage, and create custom error messages.
Escape (RegExp)
Regular expression's escape operator (\) specifies that you wish to escape a character's default type.
exec() in JavaScript
exec() executes a search for a regular expression pattern in its string argument.
Execution time
Execution time (also called runtime) is the time during which a program is running.
In other words, execution time is the execution period (or lifecycle phase) of a program—which begins from the time the program is invoked and ends when the program's invocation is closed.
Expression statement (JS)
An expression statement is any piece of code that expresses a value.
F
Fake (TDD)
Fake is a test double used to create a working test implementation of an external dependency with dynamic values.
Falsy (JS)
Falsy values are values JavaScript considers to be false.
The seven falsy values in JavaScript are: 0 (zero), false, "" (empty string), NaN, null, undefined, and 0n (BigInt zero).
File path (URL)
A URL's file path is the path (route) to a website's resource on a web server.
filter() in JavaScript
filter() creates a new array that contains all the calling array's elements that passed the test specified by the method's function argument.
Flags (RegExp)
Flags are operators used to specify how you want the computer to interpret a regular expression pattern.
for…in loop statement (JS)
A for...in loop instructs the computer to loop through each property in a given object.
for…of loop statement (JS)
A for...of loop instructs the computer to loop through each of an iterable object's values.
forEach() in JavaScript
The forEach() method executes its function argument once for each item of the calling array.
Framework
A framework is a codebase written to serve as the primary structure for your application.
Function (JS)
A JavaScript function is an executable piece of code used to bundle a block of zero or more statements.
Function component
A function component is a regular JavaScript function that can accept a single properties object (props) as its parameter and emits a React element as its return value.
Function declaration (JS)
A function declaration is a function created without assigning it to a variable.
Function definition (JS)
A function definition is a function created without assigning it to a variable.
Function expression (JS)
A function expression is a function that you create and assign to a variable.
Function statement (JS)
A function statement is a function created without assigning it to a variable.
Function's body (JS)
A function's body is where you place a sequence of statements that you want to execute.
G
Git
Git is a Distributed Version Control System (DVCS) used to save different versions of a file (or set of files)—wherein any version is retrievable at will.
Git makes it easy to record and compare different file versions. Consequently, details about what changed, who changed what, or who initiated an issue are reviewable anytime.
Git cloning
Git Cloning is mainly about getting (downloading) a copy of a .git repository.
Git commit
Whenever you commit your files to Git, it means you have stored the staged version of your working directory's file(s) into the .git repository.
Git directory
Git directory is a folder Git creates in the working directory you instructed it to monitor.
Git initialization
Initialization is to make Git ready to start monitoring files in a specified directory.
Git staging
Staging implies that you have added details about your staged file(s) into a file called "index"—located in the Git directory.
GitHub
GitHub is a web-based platform for hosting (or sharing) Git repositories. It helps you facilitate easy sharing and collaboration on projects with anyone at any time.
GitHub also encourages broader participation in open-source projects by providing a secure way to edit files in another user's repository.
Global (RegExp)
Regular expression's global flag (g) tells the computer to do a global search for a RegExp pattern.
Globally installed package
A globally installed package is a package that you can use anywhere on your system.
Graphical data
Graphical data are the visual contents of a page, such as diagrams, charts, videos, and images.
Greater than operator (JS)
The greater than operator (>) checks if its left operand is greater than its right-hand one. If so, the Boolean value true gets returned. Otherwise, the computer will return false.
Greater than or equal to operator (JS)
The greater than or equal to operator (>=) checks if its left operand is greater than or equal to its right-hand operand. If so, the Boolean value true gets returned. Otherwise, the computer will return false.
Greedy quantifiers (RegExp)
Greedy quantifiers are quantifier operators that will automatically find the longest part of the given string that matches the specified RegExp pattern.
Groups and ranges (RegExp)
The groups and ranges operators specify the groups and ranges of characters you wish to find in a specific string.
H
HEAD pointer (Git)
The HEAD pointer is a marker Git uses to reference your project's active branch (or commit).
In other words, the HEAD pointer is an indicator that shows a project's currently checked-out branch or commit.
Hoisting (JS)
Hoisting refers to JavaScript giving higher precedence to the declaration of variables, classes, and functions during a program's execution.
HTML
HTML (HyperText Markup Language) is an extension of plain texts. It is a note to browsers about a document's data, thereby helping browsers present webpages accurately.
Hyper
Hyper means Extensive (that is, an extension of another thing).
HyperLink
HyperLink means ExtensiveLink (that is, a link that acts as an extension of another link).
HyperSpace
HyperSpace means ExtensiveSpace (that is, a space that acts as an extension of another space).
HyperText
HyperText means ExtensiveText (that is, a text that acts as an extension of another text).
I
if conditional statement (JS)
The if conditional statement instructs the computer to execute a JavaScript code block only if a specified condition is true.
Ignore case (RegExp)
The ignore case flag (i) tells the computer to do a case-insensitive search for a RegExp pattern.
Immediately invoked function expression (IIFE)
An immediately invoked function expression (IIFE) is a function expression that invokes itself automatically.
import.meta (ES Module)
The import.meta code is an object containing information about your current module.
Impure function
An impure function is a function that contains one or more side effects.
Index (JS)
Index refers to the position of items in an array object.
Array's indexing starts at zero. In other words, the index of an array's first item is 0. The second value's index is 1. And the last item's index is the array's length minus 1.
For instance, consider this array object:
["Blue", "White", "Pink", "Green"];
Here are the index positions of the array items above:
- Blue is at index 0
- White's index position is 1
- Pink's index is 2
- Green's index position is 3
indexOf() JavaScript Array Method
indexOf() searches its calling array for the first occurrence of the method's string argument.
indexOf() JavaScript String Method
indexOf() searches its calling string for the first occurrence of the method's string argument.
Indices (RegExp)
Regular expression's indices flag (d) tells the computer to include each capturing group's start and end indices in the result of the matched RegExp pattern.
Initialization
Initialization occurs when you assign an initial value to a variable.
Instructing language
An instructor directs the action of a page and its contents. For instance, JavaScript is a commanding language that commands the items of an HTML document.
Integration test (TDD)
An integration test is a test written to assess the functionality of a dependent piece of program.
Internet
The internet is one means through which data gets shared between two or more computers.
In other words, the internet is like a conveyor used to transport goods from one location to another.
Photo of conveyors transporting goods – Image by Falco
Keep in mind that Bluetooth and ultra-wideband are other means through which two or more computers can share data.
Inversion of control
Inversion of control (IoC) occurs when you transfer the control of your code's execution to a third party.
Invocation
Invocation means to execute a piece of code.
Iterable
An iterable is an object that has a property with a @@iterator key.
Iteration statement (JS)
An iteration statement is any piece of code that allows you to repeat a program's execution easily and quickly.
J
JavaScript
JavaScript is a commanding language that commands the items of an HTML document.
JSX
JSX (JavaScript and XML) is a syntax extension to JavaScript that allows you to build React elements with HTML-like syntax right inside your JavaScript code.
L
lastIndexOf() JavaScript Array Method
lastIndexOf() searches its calling array for the last occurrence of the method's argument.
lastIndexOf() JavaScript String Method
lastIndexOf() searches its calling string for the last occurrence of the method's argument.
Lazy quantifiers (RegExp)
Lazy quantifiers are quantifier operators that will automatically find the shortest part of the given string that matches the specified RegExp pattern.
Left-hand side expression (JS)
A left-hand side expression is a piece of code on the left-hand side of an assignment operator.
Less than operator (JS)
The less than operator (<) checks if its left operand is less than its right-hand one. If so, the Boolean value true gets returned. Otherwise, the computer will return false.
Less than or equal to operator (JS)
The less than or equal to operator (<=) checks if its left operand is less than or equal to the one on the right-hand. If so, the Boolean value true gets returned. Otherwise, the computer will return false.
Lexical
Lexical refers to the definition of things.
Lexical scope
Lexical scope is the definition area of an expression.
Lexicon
A lexicon is a dictionary where words are listed and defined.
Library
A library is a codebase written to act as an add-on feature to your application.
Lifecycle (ReactJS)
The lifecycle of a React component refers to the series of stages a component instance goes through from its creation to its total removal from the DOM.
Lifecycle methods (ReactJS)
Lifecycle methods are the inbuilt React methods you can use to operate on your components during their lifecycle in the DOM.
Locally installed package
A locally installed package is one that you can use only in the project in which you've installed it.
Logic (JS)
Logic is the analytical action performed by a computer, which often requires the computer to decide if a specific condition is true or false.
Logical expression (JS)
A logical expression is a piece of code that expresses the Boolean values, true or false.
Loop statement (JS)
A loop statement is any piece of code that allows you to repeat a program's execution easily and quickly.
M
map() in JavaScript
map() creates a new array that contains the result of invoking map()'s function argument on each item of the calling array.
Markup
Markup means annotate (that is, a note added to a piece of writing). They are the part of an HTML text that tells browsers how they should display the text.
match() in JavaScript
match() creates a new array containing all the patterns that match the method's regular expression argument.
matchAll() in JavaScript
matchAll() creates a new iterator object containing all the patterns—including capturing groups—that match the method's regular expression argument.
Metacharacters (RegExp)
Regular expression's metacharacters are operators used to specify the precise type of characters you wish to find in a specific string.
Method
A method is a function encased in a properties object as one of the object's property's values.
Minimax algorithm
A minimax algorithm is a recursive program written to find the best gameplay that minimizes any tendency to lose a game while maximizing any opportunity to win the game.
In other words, minimax is a recursive function created to help a player (the maximizer) decide on the gameplay that minimizes the maximum possibility to lose a game.
Mock (TDD)
Mock is a test double used to mimic an external dependency without considering the responses the dependency may return.
Modifiers (RegExp)
Modifiers are operators used to specify how you want the computer to interpret a regular expression pattern.
Module (NodeJS)
A module in NodeJS is any file in the node_modules folder that the computer can load through Node's require() function.
Module bundler (JavaScript)
A module bundler is a tool developers use to bundle an app's modules and dependencies into a single browser-compatible JavaScript file.
Modules (JavaScript)
A JavaScript module is a file that allows you to export its code. Therefore, allowing other JavaScript files to import and use the exported code as their dependencies.
Mounting phase (ReactJS)
A component's mounting phase is when the component instance is being created and rendered into the DOM.
Multi-line (RegExp)
Regular expression's multi-line flag (m) tells the computer to do a multiline search for a RegExp pattern.
Multi-page application
A multi-page application (MPA) is a web app in which each of its unique URL file paths refers to a brand-new HTML page that needs to be reloaded from the server each time users request the page.
N
Named capturing group (RegExp)
The named capturing group operator (?<name>) defines the name of a capturing group.
Named function
A named function is a function with a name.
Namespace
A namespace is a named container (variable) used to store objects of any type.
Negative lookahead (RegExp)
Regular expression's negative lookahead operator (p(?!sp)) asserts that you wish to find a RegExp pattern that is not followed by another pattern.
Negative lookbehind (RegExp)
A regular expression's negative lookbehind operator ((?<!sp)p) asserts that you wish to find a RegExp pattern that is not preceded by another pattern.
Networking
Networking means connecting things.
New line character
The new line character (\n) helps create line breaks in strings.
node_modules
node_modules is a folder NPM uses to store all the packages downloaded locally for your project.
Non-assignment expression (JS)
A non-assignment expression is a piece of code that does not assign its evaluated value to any variable (or property).
Non-capturing group (RegExp)
A regular expression's non-capturing group operator (?:) allows you to group a pattern without capturing (saving) it.
Non-greedy quantifiers (RegExp)
Non-greedy quantifiers are quantifier operators that will automatically find the shortest part of the given string that matches the specified RegExp pattern.
Non-primitive data (JS)
Non-primitive data is a JavaScript value that can contain multiple other values.
Non-restartable iterator (JS)
A non-restartable iterator is an object you can use only once. Any subsequent iteration after the first will return nothing.
An example of a non-restartable object is matchAll()'s returned value.
Example
// Match a regular expression's pattern against a string and assign the result to a variable:
const result = "Tuesday".matchAll(/day/g);
// Print the result variable's content on the console:
console.log(result); // RegExp String Iterator { }
// Print the result variable as an array on the console:
for (const arrayVersion of result) {
console.log(arrayVersion); // ['day', index: 4, input: 'Tuesday', groups: undefined]
}
// Print the result variable as an array on the console again:
for (const arrayVersion of result) {
console.log(arrayVersion); // undefined
}
You can see that the second for...of loop statement printed undefined. This is because the result variable contains a non-restartable iterator object which you can use only once.
tip
To reuse the result variable, use the spread operator to convert the iterator from a non-restartable to a restartable object.
Example
// Match a regular expression's pattern against a string and assign the result to a variable:
const result = [..."Tuesday".matchAll(/day/g)];
// Print the result variable's content on the console:
console.log(result); // [['day', index: 4, input: 'Tuesday', groups: undefined]]
// Print the result variable as an array on the console:
for (const arrayVersion of result) {
console.log(arrayVersion); // ['day', index: 4, input: 'Tuesday', groups: undefined]
}
// Print the result variable as an array on the console again:
for (const arrayVersion of result) {
console.log(arrayVersion); // ['day', index: 4, input: 'Tuesday', groups: undefined]
}
Non-word boundary (RegExp)
Regular expression's non-word boundary operator (\B) asserts that you wish to find the RegExp pattern that is not at the starting (or ending) boundary of a word.
NOT (RegExp)
A regular expression's NOT operator ([^abc]) defines the set of characters you do not wish to find in a single character's position.
NOT equal to operator (JS)
The NOT equal to operator (!=) checks if its two operands are not of equal value. If so, the Boolean value true gets returned. Otherwise, the computer will return false.
NOT operator (JS)
The NOT operator (!) is used to negate the Boolean value of an expression. In other words, it converts true to NOT true and false to NOT false.
NOT strictly equal to operator (JS)
The Not strictly equal to operator (!==) checks if its two operands are strictly not of equal type and equal value. If so, the Boolean value true gets returned. Otherwise, the computer will return false.
NPM
NPM (Node Package Manager) is a package manager (an alternative to Yarn) that automatically helps find and execute a specified package.
NPX
NPX is node's package runner tool. It helps to automatically find and execute a specified package.
Null (JS)
Use null to indicate an intentional absence of a value.
Nullish coalescing operator (JS)
The nullish coalescing operator (??) checks if its left-hand side operand is undefined or null. If so, it returns its right-hand side operand. Otherwise, it produces its left-hand side operand.
Number (JS)
A number is a double-precision 64-bit floating-point arithmetic data.
O
Object (JS)
An object is a non-primitive JavaScript component that you can use to bundle multiple items into a single one.
Object destructuring (JS)
Object destructuring is a unique technique you can use to copy an object's values into new variables neatly.
OR (RegExp)
A regular expression's OR operator (x|y) defines the two alternative patterns you wish to find in a string.
OR operator (JS)
The OR operator (||) checks and returns true if one (or both) of its operands is true. Otherwise, it returns false if both of its operands are false.
Output file
An output file is the compiled version of an entry file. In other words, an output script file refers to the JavaScript file a bundler generates automatically for your project.
P
Package
A package is a directory (or project) that has a package.json file used to record information about it.
package.json
package.json is a file that package managers—like NPM and Yarn—use to store information about your project.
package-lock.json
package-lock.json is a file that NPM uses to record the exact version of all the packages you've installed locally to your project's node_modules directory.
Package manager
A package manager is a tool developers use to automatically find, download, install, configure, upgrade, and uninstall a computer's packages.
Package registry
A package registry is a database (storage) for thousands of packages (libraries, plugins, frameworks, or tools).
Parameter (JS)
A parameter specifies the name you wish to call your function's argument.
Parameter (URL)
A parameter (query string) allows you to send specific data to the server.
Parent module (ES Module)
A parent module is an aggregator file used solely to aggregate and re-export submodules.
Period (RegExp)
Regular expression's period operator (.) specifies that you wish to find any character that is not the newline or any other line terminator characters.
pop() in JavaScript
pop() removes its calling array's last item.
Port (URL)
A port is a technical gate on a website's server from which browsers can access a site's resources.
Positive lookahead (RegExp)
Regular expression's positive lookahead operator (p(?=sp)) asserts that you wish to find a RegExp pattern that is followed by another pattern.
Positive lookbehind (RegExp)
The positive lookbehind operator ((?<=sp)p) asserts that you wish to find a RegExp pattern that is preceded by another pattern.
Primary expression (JS)
A primary expression is a piece of code that serves as the basis for creating other expressions.
Primitive data (JS)
Primitive data is any plain JavaScript value that you can use to program a webpage and its content.
Program
A program is a list of instructions written for a computer to execute.
Promise (JavaScript)
A JavaScript promise refers to the object you create from JavaScript's built-in constructor function—called Promise.
Properties object (JavaScript)
A properties object is an element you can use to bundle up multiple named values into a single item.
Pure function
A pure function is a function without any side effects.
push() in JavaScript
push() adds its arguments to the end of its calling array and returns the calling array's new length.
Q
Quantifiers (RegExp)
Regular expression's quantifiers operators specify the quantity of characters or expressions you wish to find in a specific string.
Quantity specifier (RegExp)
Regular expression's quantity specifier operator ({...}) specifies that you wish to find a repeated occurrence of the operator's preceding item.
Question mark operator (JS)
A question mark operator is an alternate (shortcut) way of writing an if...else statement.
R
React component
A component is a JavaScript function (or class) that can accept arbitrary inputs (called "props") and returns an element (UI).
React element
React element is the specific user interface (UI) you want to see displayed on-screen.
React hooks
React hooks are functions used in a function component to hook into React's state object, lifecycle methods, and other React features without writing a class component.
React props
React props are parameters used to pass arguments to components.
React Router
React Router is a popular routing library that tells React the specific component it should render based on the route (file path) a user requested through the URL.
React state
React state is a built-in object used to store a component's values that are likely to change over time.
ReactJS
React is a component-based JavaScript library used to build user interfaces (UI) efficiently.
Recursion
Recursion is a method by which a problem gets solved through iteration.
In other words, a recursive function is a function that repeatedly invokes itself infinitely (or until something stops it).
Regular expression
A regular expression (RegExp) is a JavaScript element used to bundle the patterns you wish to find in a specific string of characters such as text, password, and email address.
Relative length units
Relative length units are dynamic units. In other words, the sizes of things expressed in any of the relative length units will always be dependent on another length.
Repeat (RegExp)
Regular expression's repeat operator ({...}) specifies that you wish to find a repeated occurrence of the operator's preceding item.
replace() in JavaScript
replace() returns a new version of its calling string after replacing some specified patterns with a given replacement.
Rest operator (JS)
The rest operator is used to put the rest of some specific user-supplied values into a JavaScript array.
Rest parameter (JS)
A JavaScript rest parameter consists of the rest operator and a regular parameter.
Rest variable (JS)
A JavaScript rest variable consists of the rest operator and a regular variable.
Restartable iterator
A restartable iterator is an object you can use numerous times. An example is the JavaScript array.
Root directory
Root directory refers to the folder containing all other files and sub-folders of a specific project.
In other words, a root repository is a working directory that houses everything concerning a particular project.
Root-level domain
The root-level domain ("") is the highest hierarchy level of any domain name system.
Router
A router is a code logic used to handle a client's request to a specific file path.
Runtime
Runtime (also called execution time) is the time during which a program is running.
In other words, runtime is the execution period (or lifecycle phase) of a program—which begins from the time the program is invoked and ends when the program's invocation is closed.
S
Scheme (URL)
A scheme indicates the protocol (set of rules) browsers must use to access a website's resources. Some popular schemes are HTTP, HTTPS, Mailto, and FTP.
Scope
Scope refers to the area where an item (such as a function or variable) is visible and accessible to other code.
Scope chain
A scope chain refers to the unique spaces that exist from the scope where a variable got called to the global scope.
search() in JavaScript
search() searches its calling string for the first occurrence of the method's regular expression argument.
Search engine
A search engine is a software program you can use to search for resources on the internet.
In other words, a search engine is like a marketplace where you search for products.
A woman searches for vegetables at a marketplace – Image by Milada Vigerova
Popular search engines are Google, Bing, Yahoo, Yandex, CC Search, and DuckDuckGo.
Self-executing anonymous function expression
An self-executing anonymous function expression is a function expression that invokes itself automatically.
Self-invoking function expression
An self-invoking function expression is a function expression that invokes itself automatically.
Server (computing)
A server is a computer where documents (such as webpages, videos, audios, and images) are stored until other computers request them over the internet (or local network).
In other words, a server is like a warehouse where goods are stored until people request them.
Photo of a flower warehouse – Image from Pixabay
setState() in React
setState() is the method used to update a class component's state.
Shallow copy (JS)
You do shallow copy when you create references while cloning one object into another.
Shallow object (JS)
A shallow object is one that contains only primitive items.
shift() in JavaScript
shift() removes its calling array's first item.
Side effect
Side effect occurs in a program whenever you use an external code in your function—which, as a result, impacts the function's ability to perform its task.
Single-page application
A single-page application (SPA) is a web app in which each of its unique URL file paths refers to a single HTML page that gets loaded only once from the server.
slice() in JavaScript
slice() extracts a specified part of its calling array into a new array—without altering the original array.
Source code
A source code is your original file containing the code you wrote and edited. It is the source code that bundlers compile into a distribution code.
splice() in JavaScript
splice() alters its calling array by adding or removing a specific number of items to/from it.
split() in JavaScript
split() returns an array containing the result of splitting a string into substrings.
Spread operator
The spread operator (...) helps you expand iterables into individual elements.
Staging area (Git)
The staging area is a file Git uses to store details about files it is about to commit into the .git directory.
Start of (RegExp)
Regular expression's start of operator (^) asserts that you wish to find the RegExp pattern at the start of a string.
State
State is the specific data managed by a stateful program.
State hook (ReactJS)
The state hook (useState) allows a function component hook into React's state object.
Stateful program
A stateful program is a program whose output depends on external states (events).
Stateless program
A stateless program is one whose output does not depend on any external event.
Statement (JS)
A JavaScript statement is a piece of code used to instruct the computer on an action to execute.
Sticky (RegExp)
Regular expression's sticky flag (y) tells the computer to find a RegExp pattern at exactly the lastIndex position—not starting from the lastIndex position.
Strict equality operator (JS)
The strict equality operator (===) checks if its two operands are strictly of equal type and value.
Strict mode (JS)
JavaScript's strict mode is a way of ensuring the code in a script (or function) are strictly JavaScript code—not generic code nor mistyped JavaScript code.
You can invoke the strict mode by including the literal string "use strict"; as the first statement of your script file (or function statement).
String (JS)
A string is a quoted series of characters representing textual data.
String expression (JS)
A string expression is a piece of code that expresses a string value.
Stub (TDD)
A stub is a test double used to mimic an external dependency while also returning hand-coded values that you can use to assess your program's behavior with various test case responses from the dependency.
Styling language
A stylist helps to apply styles to an annotated document. So, for instance, CSS helps add artistic touches to the elements of an HTML document.
Subdomain
A subdomain (third-level domain) is a subset of a specific website. It allows you to categorize your website into one or more sections.
Submodule (JavaScript)
A submodule is a script used inside another module.
Substitutions (Webpack)
Substitutions—in webpack—refers to the use of bracketed strings to create templates for filenames.
switch conditional statement (JS)
The switch conditional statement instructs the computer to execute a code block if the block's case value matches the given expression.
Symbol (JS)
Symbol is a unique, anonymous value that you can create by invoking the Symbol() function in a JavaScript runtime environment.
Synchronous callback
A synchronous callback is a callback whose execution happens immediately.
Synchronous event
A synchronous event is an activity that must occur at a specific point in time.
T
Temporal Dead Zone (JS)
A temporal dead zone (TDZ) is the area of a block where a variable is inaccessible until the moment the computer completely initializes it with a value.
Ternary operator (JS)
A ternary operator is an alternate (shortcut) way of writing an if...else statement.
Test doubles (TDD)
Test doubles are the imitation objects used to mimic real dependencies like databases, libraries, networks, and APIs.
test() in JavaScript
test() tests its string argument for an occurrence of a regular expression.
Test-driven development
Test-driven development is a coding practice where you write the result you want your program to produce before creating the program.
Text
Text is any writing that is composed of characters—and every application needs lots of them.
Keep in mind that text is the predominant content of a software application.
For instance, consider this HTML document:
<html>
<head>
<meta charset="UTF-8" />
<style>
.tenor-gif-embed {
border: 7px solid #000000;
}
</style>
</head>
<body>
<div
class="tenor-gif-embed"
data-postid="18866548"
data-share-method="host"
data-aspect-ratio="1"
data-width="100%"
>
<a
href="https://tenor.com/view/celebration-dancing-students-students-celebrating-chicken-dance-gif-18866548"
>Celebration Dancing GIF</a
>from
<a href="https://tenor.com/search/celebration-gifs">Celebration GIFs</a>
</div>
<script
type="text/javascript"
async
src="https://tenor.com/embed.js"
></script>
</body>
</html>
Above is an HTML document containing a GIF animation with some CSS and JavaScript code.
Observe that even though the app above got configured to display only a GIF animated image, the app's content is 100% text.
That is to say, "text" is an essential tool of every web application.
Text Markup
Text Markup means Text Note (that is, the note added to a text to help typesetters (or computers) better understand how to present the marked-up text).
Textual data
Textual data are the written contents of a page, such as letters (e.g., A, B, C), numbers (e.g., 1, 2, 3), symbols (e.g., $, #, +), and code (e.g., <input>, body { background: #A18A77; }, if (condition) { //execute code }).
Thenable (JavaScript)
Thenable in JavaScript refers to any object that contains a then() method.
this (JS)
JavaScript's this keyword refers to the owner object of the keyword's method or the this value of an arrow function's lexical context.
TO (RegExp)
A regular expression's TO operator ([a-z]) defines the range of characters you wish to find in a single character's position.
toLowerCase() in JavaScript
toLowerCase() returns the lowercase version of its calling string.
Top-level domain
The top-level domain (TLD) is what follows the domain name in a URL.
Top-level module (JavaScript)
A top-level module is a script containing other modules.
toUpperCase() in JavaScript
toUpperCase() returns the uppercase version of its calling string.
Truthy (JS)
Truthy values are values JavaScript considers to be true.
All JavaScript's values are true except 0 (zero), false, "" (empty string), NaN, null, undefined, and 0n (BigInt zero)—which are falsy.
U
Uncontrolled component (ReactJS)
An uncontrolled component is a component whose form's data React does not control exclusively.
undefined (JS)
JavaScript automatically assigns undefined to any variable you declare without an initial value.
Unicode (RegExp)
Regular expression's Unicode flag (u) tells the computer to search for Unicode RegExp patterns.
Unit
A unit is anything accepted as a gauge for expressing the quantity or size of another thing.
Unit test (TDD)
A unit test is a test written to assess the functionality of an independent piece of program.
Unmounting phase (ReactJS)
A component's unmounting phase is when the component's instance is being removed from the DOM.
unshift() in JavaScript
unshift() adds its arguments to the beginning of its calling array and returns the calling array's new length.
Updating phase (ReactJS)
A component's updating phase is the period when the component instance is being updated.
URL (Uniform Resource Locator)
A URL is a website's specific location on the web.
V
Variable (JavaScript)
A JavaScript variable is a container used to store JavaScript data (values).
Variable Keyword (JavaScript)
A JavaScript variable keyword is a code used to declare that a specific variable is a JavaScript variable—not a mathematical or generic variable.
Version Control System
A Version Control System (VCS) refers to the specific method employed to save a file's versions for future references.
W
Web address
A web address is a website's specific location on the web.
Webpage
A web page is a single code file configured by an editor to interconnect with other documents on the World Wide Web (WWW).
Website
A website is a set (or collection) of web pages configured by an editor to interconnect with other documents on the World Wide Web (WWW).
while loop statement (JS)
A while loop instructs the computer that while a specified condition is true, it should execute the while loop's code block repeatedly.
Wildcard (RegExp)
Regular expression's wildcard operator (.) specifies that you wish to find any character that is not the newline or any other line terminator characters.
Word boundary (RegExp)
Regular expression's word boundary operator (\b) asserts that you wish to find the RegExp pattern at a word's starting (or ending) boundary.
Working directory
A working directory is a local folder you create to store all your project's files.
As such, any folder you create anywhere on a system is a working directory.
Workstation
A workstation is a powerful computer (or laptop) used for technical and engineering works like software development, computer-aided designs (CAD), and other graphics-intensive projects.
Y
Yarn
Yarn is a package manager (an alternative to NPM) that automatically helps find and execute a specified package.
yarn.lock
yarn.lock is a file that Yarn uses to record the exact version of all the packages you've installed locally to your project's node_modules directory.
Z
Zero or more (RegExp)
Regular expression's zero or more operator (*) specifies that you wish to find zero or more occurrences of its preceding item.
Zero or one (RegExp)
Regular expression's zero or one operator (?) specifies that you wish to find zero or one occurrence of its preceding item.