JavaScript Terms to Know | Basic & Advanced

Arity This basically refers to the number of arguments or operands in a function or operation respectively. In JavaScript, this is most often used to describe the number of arguments expected by a JavaScript function.

There is even a property named arity, of the Function object that returns the number of expected arguments in a function. It is now obsolete though and replaced by length.

The following function has an arity of 3.

function userInfo(name, id, address) {
return name + ' ' + id + ' ' + address;


}

Anonymous Function This type of function is not identified by a name. 
This is an IIFE (Immediately Invoked Function Expression). The function in it is anonymous since it doesn’t have a name.

(function (){
                        // Code here...
                    })();

Below is also an anonymous function because there is no name after the keyword function.

var foo = function() {
    // Code here...
};

Closure In JavaScript, closure is an inner function, that is accessible outside of its outer function’s scope, and maintains its connection to the outer function’s variables.

JavaScript closures are able to take parameters and bring back references to variables from inside a function that, otherwise, would be inaccessible.

function vacation() {

var trip;

function travelAgent(itinerary) {
    agent(itinerary);
    return trip;
}

function agent(itinerary) {
    if (itinerary === 'Orlando') {
        trip = ['Orlando', 'Disney', 'Universal'];
        book();
    }
}

function book() {
    trip.push('booked');
}
return travelAgent;
}

var myVacation = vacation();

console.log(myVacation('Orlando'));

// Array [ "Orlando", "Disney", "Universal", "booked" ]

In this code above, only travelAgent() (and its return value from inside thebook() function) is exposed to the outside world.

CurryingThe effect, named after Haskell Curry, is a process of using multiple functions with single arguments, in place of a single function with multiple arguments.

function addA(a) {
function addB(b) {
    return a + b;
}
return addB
}

function add(a, b) {
return (a + b);
}

console.log(addA(3)(4)); \ 7
console.log(add(3, 4)); \ 7

Both of the functions above return the same result. The function addA accepts a parameter a while returning addB which in turn accepts the b value, performs the addition with a and returns the sum. The function add simply takes both a and b at the same time, performs the addition and returns the sum. So far the first function might not seem useful, until…

var add7 = addA(7);
console.log(add7(8)); //15
console.log(add7(6)); //13
console.log(add7(-21)); //-14

In currying, if you fix a step, like the addition of 7 above, you can streamline the process when a variable used in the operation is always the same.

Hoisting Most variable & function declarations are moved, or hoisted, to the top of the evaluation order.

With this, it does not matter where you type the code to declare a function or variable. During evaluation, all the declarations are moved up inside their current scope. With this, it is possible to write a function call before function is declared. Note: When in "strict mode", this behavior is changed. In strict mode, bad syntax is not allowed, hoisting is not done, silent errors are shown, etc. It helps in writing a more secure and optimized JavaScript code.

var name = 'Terry';
console.log(grabPassword(name)); // "terryPassword"

function grabPassword(name) {
phrases = {
'James': 'jamesPassword',
'Terry': 'terryPassword',
'Morgan': 'morganPassword'
};
return phrases[name];
}

Mutation A Mutation, in JavaScript, refers to the changes that DOM elements received.

To illustrate, there is an API called MutationObserver to help watch for the DOM mutations, like adding child elements or changes to the element’s attributes.

Object State There is no official term "State" in Javascript, but this term is often used to refer to an Object's internal prperties values. This is most used in frameworks like React.js and others, but the principle is basilaly the same. As an Onject's property value changes, the state changes.

Pragma is short for 'pragmatic information'. In programming, pragma refers to the code that consist of useful information on how a compiler, interpreter or assembler should process the program.

It does not contribute anything to the programming language itself and its syntax may vary. pragma only affect the compiler behavior. JavaScript has a few pragmas, one of them is strict.

"use strict";

Sentinels In programming, sentinels are values that are used to indicate the end of a loop or process. They can also be called “flags”.

You can use any value as a sentinel. Here’s an example of sentinels used in JavaScript; the

indexOf

method which returns -1 (the sentinel value) when the search value is not found in the targeted string. Below is a function that returns the position of an array value and if value is not found, returns -1.

function findArrayPosition(ary, val) {
var i = 0,
    len = ary.length;
for (; i & lt; len; i++) {
    if (ary[i] === val) return i + 1;
}
return -1;


}
console.log(findArrayPosition(['a', 'b', 'c'], 'b')); // 2
console.log(findArrayPosition(['a', 'b', 'c'], 'z')); // -1

Variadic In English, variadic is an adjective created by joining “variable” and “adicity” (which basically means arity“ ); Ultimately, this variadic is used to express something that has variable number of arguments.

More specifically to JavaScript, a variadic function takes in any number of arguments. It can be created using the arguments property, apply method and, since ES6, the spread operator. Below is an example using a spread operator.

function test(...a) {
console.log(a);
}
test('a', 'b', 'c', 8, [56, -89]);
//output is Array [ "a", "b", "c", 8, Array[2] ]

---

The definitions and code used in this section are compiled and rewritten into more plain English, from the following sources (If I have forgotten others please let me know and I will add them):
https://developer.mozilla.org/en-US/docs/Web/JavaScript
https://www.hongkiat.com/blog/javascript-jargon/