Jssut-name.EXTERNAL (reference)

description::
· we can-assign|bind a-name to a-semantic-unit.
· this name it is-not a-member of the-semantic-unit.
· I call it EXTERNAL-NAME.
· a-semantic-unit can-have many external-names.
[HmnSgm.2018-01-06]
===
The-name of a-name-value-pair is-called idenfier.
An-identifier must start with a letter, underscore (_), or dollar sign ($); subsequent characters can also be digits (0-9).

name::
* McsEngl.external-name--of--semantic-unit//Javascript,
* McsEngl.lagJsgn'reference,
* McsEngl.lagJsgn'reference-name,
* McsEngl.Jssut'reference-name,
* Jssut-name.external,
* Jssut-name.reference,
* McsEngl.lagJsgn'variable-name,
* McsEngl.lagJsgn'variable-reference,
* McsEngl.reference-name--of--semantic-unit//Javascript,

Jssut.custom.OWN (dependencyNo)

description::
A-semantic-unit created by a-programer in a specific program|library.

name::
* McsEngl.lagJsgn'customInternal-semantic-unit,
* McsEngl.lagJsgn'customOwn-semantic-unit,
* McsEngl.lagJsgn'dependencyNo-semantic-unit,
* McsEngl.lagJsgn'dependentNo-semantic-unit,
* McsEngl.lagJsgn'independent-semantic-unit,
* McsEngl.lagJsgn'ownCustom-semantic-unit,
* McsEngl.Jssut.customOwn,

Jssut.custom.OWN.NO (dependency)

description::
A-semantic-unit created by a-programer in ANOTHER program|library.

name::
* McsEngl.lagJsgn'customExternal-semantic-unit,
* McsEngl.lagJsgn'customOwnNo-semantic-unit,
* McsEngl.lagJsgn'dependency-semantic-unit,
* McsEngl.lagJsgn'dependent-semantic-unit,
* McsEngl.lagJsgn'independentNo-semantic-unit,
* McsEngl.lagJsgn'ownNoCustom-semantic-unit,
* McsEngl.Jssut.customOwnNo,

Array.prototype'member

member::
Code
(Jsnd.6-2-2):
> Object.getOwnPropertyNames(Array.prototype).sort()
[ 'concat', 'constructor', 'copyWithin', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift' ]
(Chrome.50):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "copyWithin", "entries", "every", "fill", "filter", "find", "findIndex", "forEach", "includes", "indexOf", "join", "keys", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toString", "unshift"]
(Firefox.45):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "copyWithin", "entries", "every", "fill", "filter", "find", "findIndex", "forEach", "includes", "indexOf", "join", "keys", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toSource", "toString", "unshift"]
(Edge.20):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "copyWithin", "entries", "every", "fill", "filter", "find", "findIndex", "forEach", "indexOf", "join", "keys", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toString", "unshift", "values"]
(Safari.5-1-7):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "every", "filter", "forEach", "indexOf", "join", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toString", "unshift"]

Array.prototype.concat-function

description::
The concat() method is used to merge two or more arrays. This method does not change the existing arrays, but instead returns a new array.
var arr1 = ["a", "b", "c"];
var arr2 = ["d", "e", "f"];
var arr3 = arr1.concat(arr2);
// results in a new array [ "a", "b", "c", "d", "e", "f" ]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat]

name::
* McsEngl.Array.prototype.concat-function,
* McsEngl.Jsa'concat-function,
* McsEngl.Jsaalgo.merge-arrays,
* McsEngl.lagJsgn'concat-array-function,
* McsEngl.concat--Javascript-array-function,

Array.prototype.copyWithin-function

description::
The copyWithin() method shallow copies part of an array to another location in the same array and returns it, without modifying its size.
["alpha", "bravo", "charlie", "delta"].copyWithin(2, 0);
// results in ["alpha", "bravo", "alpha", "bravo"]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin]
===
["alpha", "bravo", "charlie", "delta"].copyWithin(1);
// results in ["alpha", "alpha", "bravo", "charlie"]

name::
* McsEngl.Array.prototype.copyWithin-function,
* McsEngl.Jsa'copyWithin-function,
* McsEngl.lagJsgn'copyWithin-array-function,
* McsEngl.copyWithin--Javascript-array-function,

Array.prototype.entries-function

description::
The entries() method returns a new Array Iterator object that contains the key/value pairs for each index in the array.
var a = ['a', 'b', 'c'];
var iterator = a.entries();
console.log(iterator.next().value); // [0, 'a']
console.log(iterator.next().value); // [1, 'b']
console.log(iterator.next().value); // [2, 'c']
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries]

name::
* McsEngl.Array.prototype.entries-function,
* McsEngl.Jsa'entries-function,
* McsEngl.lagJsgn'entries-array-function,
* McsEngl.entries--Javascript-array-function,

Array.prototype.every-function

description::
The every() method tests whether all elements in the array pass the test implemented by the provided function.
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough); // false
[12, 54, 18, 130, 44].every(isBigEnough); // true
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every]

name::
* McsEngl.Array.prototype.every-function,
* McsEngl.Jsa'every-function,
* McsEngl.Jsaalgo.test-elements-on-criterion,
* McsEngl.lagJsgn'every-array-function,
* McsEngl.every--Javascript-array-function,

Array.prototype.fill-function

description::
The fill() method fills all the elements of an array from a start index to an end index with a static value.
var numbers = [1, 2, 3]
numbers.fill(1);
// results in [1, 1, 1]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill]

name::
* McsEngl.Array.prototype.fill-function,
* McsEngl.Jsa'fill-function,
* McsEngl.Jsaalgo.fill-an-array-with-static-value,
* McsEngl.lagJsgn'fill-array-function,
* McsEngl.fill--Javascript-array-function,

Array.prototype.filter-function

description::
The filter() method creates a new array with all elements that pass the test implemented by the provided function.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter]
===
> ['a', false, 'b', undefined, 'c', null, NaN, 3].filter(Number)
< [3]
===
> Object.getOwnPropertyNames(Math).sort().filter(function(sM){return sM.match(/^[s-z]/)})
< [ 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc' ]

name::
* McsEngl.Array.prototype.filter-function,
* McsEngl.Jsa'filter-function,
* McsEngl.Jsaalgo.return-array-filtered,
* McsEngl.lagJsgn'filter-array-function,
* McsEngl.filter--Javascript-array-function,

Array.prototype.find-function

description::
The find() method returns a value of the first element in the array that satisfies the provided testing function. Otherwise undefined is returned.
function isBigEnough(element) {
  return element >= 15;
}
[12, 5, 8, 130, 44].find(isBigEnough); // 130
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find]

name::
* McsEngl.Array.prototype.find-function,
* McsEngl.Jsa'find-function,
* McsEngl.Jsaalgo'find-value-on-test,
* McsEngl.lagJsgn'find-array-function,
* McsEngl.find--Javascript-array-function,

Array.prototype.findIndex-function

description::
The findIndex() method returns an index of the first element in the array that satisfies the provided testing function. Otherwise -1 is returned.
function isBigEnough(element) {
  return element >= 15;
}
[12, 5, 8, 130, 44].findIndex(isBigEnough); // 3
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex]

name::
* McsEngl.Array.prototype.findIndex-function,
* McsEngl.Jsa'findIndex-function,
* McsEngl.Jsaalgo.find-index-on-test,
* McsEngl.lagJsgn'findIndex-array-function,
* McsEngl.findIndex--Javascript-array-function,

Array.prototype.forEach-function

description::
The forEach() method executes a provided function once for each array element.
var a = ["a", "b", "c"];
a.forEach(function(element) {
  console.log(element);
});
// a
// b
// c
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach]
===
var a = ["a", "b", "c"];
a.forEach(function(element, index, array) {
  console.log(element + index);
  //array is a
});
// a0
// b1
// c2

name::
* McsEngl.Array.prototype.forEach-function,
* McsEngl.forEach--Javascript-array-function,
* McsEngl.Jsa'forEach-function,
* McsEngl.lagJsgn'forEach-array-function,

Array.prototype.includes-function

description::
The includes() method determines whether an array includes a certain element, returning true or false as appropriate.
var a = [1, 2, 3];
a.includes(2); // true
a.includes(4); // false
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes]

name::
* McsEngl.Array.prototype.includes-function,
* McsEngl.Jsa'includes-function,
* McsEngl.Jsaalgo.test-if-includes-element,
* McsEngl.lagJsgn'includes-array-function,
* McsEngl.includes--Javascript-array-function,

Array.prototype.indexOf-function

description::
The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
var a = [2, 9, 9];
a.indexOf(2); // 0
a.indexOf(7); // -1
if (a.indexOf(7) === -1) {
  // element doesn't exist in array
}
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf]
===
> [1,2,3].indexOf(3)
2
> [1,2,3].indexOf(4)
-1
> [1,2,3].indexOf(0)
-1

name::
* McsEngl.Array.prototype.indexOf-function,
* McsEngl.Jsa'indexOf-function,
* McsEngl.Jsaalgo.find-indexOf-element,
* McsEngl.lagJsgn'indexOf-array-function,
* McsEngl.indexOf--Javascript-array-function,

Array.prototype.join-function

description::
The join() method joins all elements of an array into a string.
var a = ['Wind', 'Rain', 'Fire'];
a.join(); // 'Wind,Rain,Fire'
a.join('-'); // 'Wind-Rain-Fire'
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join]
===
> [1,2,3].join()
"1,2,3"
> [1,2,3].join(' ')
"1 2 3"
> [1,2,3].join(' and ')
"1 and 2 and 3"

name::
* McsEngl.Array.prototype.join-function,
* McsEngl.Jsa'join-function,
* McsEngl.Jsaalgo.join-elements-into-string,
* McsEngl.lagJsgn'join-array-function,
* McsEngl.join--Javascript-array-function,

Array.prototype.keys-function

description::
The keys() method returns a new Array Iterator that contains the keys for each index in the array.
var arr = ["a", "b", "c"];
var iterator = arr.keys();
console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/keys]

name::
* McsEngl.Array.prototype.keys-function,
* McsEngl.Jsa'keys-function,
* McsEngl.lagJsgn'keys-array-function,
* McsEngl.keys--Javascript-array-function,

Array.prototype.lastIndexOf-function

description::
The lastIndexOf() method returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex.
var numbers = [2, 5, 9, 2];
numbers.lastIndexOf(2); // 3
numbers.lastIndexOf(7); // -1
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf]

name::
* McsEngl.Array.prototype.lastIndexOf-function,
* McsEngl.Jsa'lastIndexOf-function,
* McsEngl.Jsaalgo.finds-last-index-of-element,
* McsEngl.lagJsgn'lastIndexOf-array-function,
* McsEngl.lastIndexOf--Javascript-array-function,

Array.prototype.length-number

description::
> ['a', 'b', 'c'].length
3
===
The maximum length until "it gets sluggish" is totally dependent on your target machine and your actual code, so you'll need to test on that (those) platform(s) to see what is acceptable.
However, the maximum length of an array according to the ECMA-262 5th Edition specification is bound by an unsigned 32-bit integer due to the ToUint32 abstract operation, so the longest possible array could have 232-1 = 4,294,967,295 = 4.29 billion elements.
[http://stackoverflow.com/a/6155063]

name::
* McsEngl.Array.prototype.length-number,
* McsEngl.Jsa'length-number,
* McsEngl.Jsaalgo.finds-length-of-arry,
* McsEngl.lagJsgn'length-array-number-member,
* McsEngl.length--Javascript-array-number-member,

Array.prototype.map-function

description::
The map() method creates a new array with the results of calling a provided function on every element in this array.
var numbers = [1, 5, 10, 15];
var roots = numbers.map(function(x){
  return x * 2;
});
// roots is now [2, 10, 20, 30]
// numbers is still [1, 5, 10, 15]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map]

name::
* McsEngl.Array.prototype.map-function,
* McsEngl.Jsaalgo.create-array-from-another,
* McsEngl.lagJsgn'map-array-function,
* McsEngl.map--Javascript-array-function,

Array.prototype.pop-function

description::
The pop() method removes the last element from an array and returns that element. This method changes the length of the array.
var a = [1, 2, 3];
a.pop();
console.log(a); // [1, 2]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop]

name::
* McsEngl.Array.prototype.pop-function,
* McsEngl.Jsa'pop-function,
* McsEngl.Jsaalgo.remove-last-element,
* McsEngl.lagJsgn'pop-array-function,
* McsEngl.pop--Javascript-array-function,

Array.prototype.push-function

description::
The push() method adds one or more elements to the end of an array and returns the new length of the array.
var numbers = [1, 2, 3];
numbers.push(4);
console.log(numbers); // [1, 2, 3, 4]
numbers.push(5, 6, 7);
console.log(numbers); // [1, 2, 3, 4, 5, 6, 7]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push]

name::
* McsEngl.Array.prototype.push-function,
* McsEngl.Jsa'push-function,
* McsEngl.Jsaalgo.adds-elements-in-the-beggining,
* McsEngl.lagJsgn'push-array-function,
* McsEngl.push--Javascript-array-function,

Array.prototype.reduce-function

description::
The reduce() method applies a function against an accumulator and each value of the array (from left-to-right) to reduce it to a single value.

var sum = [0, 1, 2, 3].reduce(function(a, b) {
  return a + b;
}, 0);
// sum is 6

var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
  return a.concat(b);
}, []);
// flattened is [0, 1, 2, 3, 4, 5]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce]

name::
* McsEngl.Array.prototype.reduce-function,
* McsEngl.Jsa'reduce-function,
* McsEngl.lagJsgn'reduce-array-function,
* McsEngl.reduce--Javascript-array-function,

Array.prototype.reduceRight-function

description::
The reduceRight() method applies a function against an accumulator and each value of the array (from right-to-left) has to reduce it to a single value.
var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) { return a.concat(b);
}, []);
// flattened is [4, 5, 2, 3, 0, 1]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight]

name::
* McsEngl.Array.prototype.reduceRight-function,
* McsEngl.Jsa'reduceRight-function,
* McsEngl.lagJsgn'reduceRight-array-function,
* McsEngl.reduceRight--Javascript-array-function,

Array.prototype.reverse-function

description::
The reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.
var a = ['one', 'two', 'three'];
a.reverse();
console.log(a); // ['three', 'two', 'one']
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse]

name::
* McsEngl.Array.prototype.reverse-function,
* McsEngl.Jsa'reverse-function,
* McsEngl.Jsaalgo.reverse-an-array,
* McsEngl.lagJsgn'reverse-array-function,
* McsEngl.reverse--Javascript-array-function,

Array.prototype.shift-function

description::
The shift() method removes the first element from an array and returns that element. This method changes the length of the array.
var a = [1, 2, 3];
a.shift();
console.log(a); // [2, 3]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift]

name::
* McsEngl.Array.prototype.shift-function,
* McsEngl.Jsa'shift-function,
* McsEngl.Jsaalgo.remove-first-element,
* McsEngl.lagJsgn'shift-array-function,
* McsEngl.shift--Javascript-array-function,

Array.prototype.slice-function

description::
The slice() method returns a shallow copy of a portion of an array into a new array object selected from begin to end (end not included). The original array will not be modified.
var a = ["zero", "one", "two", "three"];
var sliced = a.slice(1,3);
console.log(a); // [ "zero", "one", "two", "three" ]
console.log(sliced); // [ "one", "two" ]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice]
===
//create arrays from array-like
> Array.prototype.slice.call({0:'a',1:'b',2:'c',length:3})
["a", "b", "c"]
> Array.prototype.slice.call({0:'a',1:'b',2:'c'})
[]

name::
* McsEngl.Array.prototype.slice-function,
* McsEngl.Jsa'slice-function,
* McsEngl.lagJsgn'slice-array-function,
* McsEngl.slice--Javascript-array-function,

Array.prototype.some-function

description::
The some() method tests whether some element in the array passes the test implemented by the provided function.
function isBiggerThan10(element, index, array) {
  return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/some]

name::
* McsEngl.Array.prototype.some-function,
* McsEngl.Jsa'some-function,
* McsEngl.lagJsgn'some-array-function,
* McsEngl.some--Javascript-array-function,

Array.prototype.sort-function

description::
The sort() method sorts the elements of an array in place and returns the array. The sort is not necessarily stable. The default sort order is according to string Unicode code points.
var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']
var scores = [1, 10, 21, 2];
scores.sort(); // [1, 10, 2, 21]
// Watch out that 10 comes before 2,
// because '10' comes before '2' in Unicode code point order.
var things = ['word', 'Word', '1 Word', '2 Words'];
things.sort(); // ['1 Word', '2 Words', 'Word', 'word']
// In Unicode, numbers come before upper case letters,
// which come before lower case letters.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort]

name::
* McsEngl.Array.prototype.sort-function,
* McsEngl.Jsa'sort-function,
* McsEngl.Jsaalgo.sort,
* McsEngl.lagJsgn'sort-array-function,
* McsEngl.sort--Javascript-array-function,

Array.prototype.splice-function

description::
The splice() method changes the content of an array by removing existing elements and/or adding new elements.
var myFish = ["angel", "clown", "mandarin", "surgeon"];
myFish.splice(2, 0, "drum");
// myFish is ["angel", "clown", "drum", "mandarin", "surgeon"]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice]

name::
* McsEngl.Array.prototype.splice-function,
* McsEngl.Jsa'splice-function,
* McsEngl.lagJsgn'splice-array-function,
* McsEngl.splice--Javascript-array-function,

Array.prototype.toLocaleString-function

description::
The toLocaleString() method returns a string representing the elements of the array. The elements are converted to Strings using their toLocaleString methods and these Strings are separated by a locale-specific String (such as a comma “,”).
var number = 1337;
var date = new Date();
var myArr = [number, date, 'foo'];
var str = myArr.toLocaleString();
console.log(str);
// logs '1337,6.12.2013 19:37:35,foo'
// if run in a German (de-DE) locale with timezone Europe/Berlin
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString]

name::
* McsEngl.Array.prototype.toLocaleString-function,
* McsEngl.Jsa'toLocaleString-function,
* McsEngl.lagJsgn'toLocaleString-array-function,

Array.prototype.toString-function

description::
The toString() method returns a string representing the specified array and its elements.
var months = ["Jan", "Feb", "Mar", "Apr"];
months.toString(); // "Jan,Feb,Mar,Apr"
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString]

name::
* McsEngl.Array.prototype.toString-function,
* McsEngl.Jsa'toString-function,
* McsEngl.lagJsgn'toString-array-function,

Array.prototype.unshift-function

description::
The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.
var a = [1, 2, 3];
a.unshift(4, 5);
console.log(a); // [4, 5, 1, 2, 3]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift]

name::
* McsEngl.Array.prototype.unshift-function,
* McsEngl.Jsa'unshift-function,
* McsEngl.Jsaalgo.add-elements-to-beggining,
* McsEngl.lagJsgn'unshift-array-function,
* McsEngl.unshift--Javascript-array-function,

Array.prototype.values-function

description::
The values() method returns a new Array Iterator object that contains the values for each index in the array.
var a = ['w', 'y', 'k', 'o', 'p'];
var iterator = a.values();
console.log(iterator.next().value); // w
console.log(iterator.next().value); // y
console.log(iterator.next().value); // k
console.log(iterator.next().value); // o
console.log(iterator.next().value); // p
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values]

name::
* McsEngl.Array.prototype.values-function,
* McsEngl.Jsa'values-function,
* McsEngl.lagJsgn'values-array-function,
* McsEngl.values--Javascript-array-function,

Jsf'parameter

description::
In a-function's-definition, as input information we do-not-give values, we give identifiers of name-value-pairs.
These input identifiers are-called PARAMETERS.
I use the-notation: xNameIn where 'x' denotes what semantic-unit is.

name::
* McsEngl.Jsf'parameter,
* McsEngl.parameter//Jsf,

Jsf'argument

description::
When we call a-function, as input information we give values, not identifiers.
These input values are-called ARGUMENTS.

name::
* McsEngl.Jsf'argument,
* McsEngl.argument//Jsf,

Jsf.async-await

description::
· by prepending await on a-promise inside an-async-function, the-code will-stop until the-promise is-resolved or rejected.
const getFirstUserData = async () => {
 const response = await fetch('/users.json') // get users list
 const users = await response.json() // parse JSON
 const user = users[0] // pick first user
 const userResponse = await fetch(`/users/${user.name}`) // get user data
 const userData = await userResponse.json() // parse JSON
 return userData
}
getFirstUserData()
[{2022-04-04 retrieved} https://nodejs.dev/learn/modern-asynchronous-javascript-with-async-and-await]
===
"Top level await
You can use the await keyword on its own (outside of an async function) within a JavaScript module. This means modules, with child modules that use await, wait for the child module to execute before they themselves run. All while not blocking other child modules from loading."
[{2022-04-04 retrieved} https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await]

name::
* McsEngl.async-await--Javascript-function,

operand of Jsgnopr

description::
Operands are the INPUT information of operators.

name::
* McsEngl.lagJsgn'operand,
* McsEngl.Jsgnopr'operand,

Jsgnopr.SPECIFIC

specific::
* unary-operator,
* binary-operator,
* ternary-operator,
=== GENERIC::
* additive-operator,
* arithmetic-operator,
* assignment-operator,
* binary-bitwise-operator,
* binary-logical-operator,
* bitwise-operator,
* comparison-operator,
* conditional-operator,
* equality-operator,
* logical-operator,
* multiplicative-operator,
* relational-operator,
* string-operator,
=== INSTANCE::
* +operator,
* ++operator,
* +=operator,
* -operator,
* --operator,
* -=operator,
* !operator,
* !=operator,
* !==operator,
* &operator,
* &&operator,
* *operator,
* **operator,
* *=operator,
* **=operator,
* /operator,
* |operator,
* ||operator,
* |=operator,
* ^operator,
* =operator,
* ==operator,
* ===operator,
* %operator,
* %=operator,
* <operator,
* <<operator,
* <=operator,
* ?:operator,
* /=operator,
* <<=operator,
* >>=operator,
* &=operator,
* ^=operator,
* >operator,
* >>operator,
* >>>operator,
* >>>=operator,
* >=operator,
* ,operator,
* comma-operator,
* delete-operator,
* in-operator,
* instanceof-operator,
* new-operator,
* super-operator,
* typeof-operator,
* void-operator,

Jsgnopr.UNARY

description::
A unary operator requires a single operand, either before or after the operator:
operator operand
or
operand operator
For example, x++ or ++x.
[https://developer.mozilla.org/el/docs/Web/JavaScript/Guide/Expressions_and_Operators]

name::
* McsEngl.Jsgnopr.unary,
* McsEngl.lagJsgn'unary-operator,
* McsEngl.unary-operator//Javascript,

specific::
* http://www.ecma-international.org/ecma-262/index.html#sec-unary-operators,

Jsgnopr.BINARY

description::
A binary operator requires two operands, one before the operator and one after the operator:
operand1 operator operand2
For example, 3+4 or x*y.
[https://developer.mozilla.org/el/docs/Web/JavaScript/Guide/Expressions_and_Operators]

name::
* McsEngl.Jsgnopr.binary,
* McsEngl.lagJsgn'binary-operator,
* McsEngl.binary-operator//Javascript,

specific::
* http://www.ecma-international.org/ecma-262/index.html#sec-unary-operators,

Jsgnopr.TERNARY

description::
A-ternary operator requires THREE operands.
Javascript has only one ternary-operator, the-conditional-operator.
[HmnSgm.2017-10-11]

name::
* McsEngl.Jsgnopr.ternary,
* McsEngl.lagJsgn'ternary-operator,
* McsEngl.ternary-operator//Javascript,

specific::
* Conditional-operator,

IIFE

description::
It is the-sentence in the-code that defines and calls the-function.

name::
* McsEngl.IIFE'(immediately-invoked-function-expression)//Javascript,
* McsEngl.immediately-invoked-function-expression//Javascript,
* McsEngl.lagJsgn'IIFE,

Number.prototype.toLocaleString-function

example::
(123456789).toLocaleString() //123,456,789

name::
* McsEngl.lagJsgn'Number.prototype.toLocaleString-function,
* McsEngl.Number.prototype.toLocaleString-function//Javascript,

String.prototype.codePointAt-function

description::
· returns the-decimal Unicode-code-point of a-character in a-string.

name::
* McsEngl.lagJsgn'codePointAt-function,
* McsEngl.Jsf.codePointAt-of-string,
* McsEngl.String.prototype.codePointAt-function,
* McsEngl.codePointAt-function--of--Javascript-string,

example::
"𝌆".codePointAt(0) //119558

String.prototype.match-function

description::
The match() method retrieves the matches when matching a string against a regular expression.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match]

name::
* McsEngl.lagJsgn'match-function,
* McsEngl.Jsf.match-of-string,
* McsEngl.String.prototype.match-function,
* McsEngl.match-function.string//Javascript,

example::
'abd'.match(/[\u0020-\u007E]/i)
//["a", index: 0, input: "abd", groups: undefined]

String.prototype.replace-function

description::
The replace() method returns a new string with some or all matches of a pattern replaced by a replacement. The pattern can be a string or a RegExp, and the replacement can be a string or a function to be called for each match.
Note: The original string will remain unchanged.
Syntax: str.replace(regexp|substr, newSubstr|function)
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace]

name::
* McsEngl.lagJsgn'replace-function,
* McsEngl.Jsf.replace-of-string,
* McsEngl.String.prototype.replace-function,
* McsEngl.replace-function.string//Javascript,

example::
> 'string'.replace('n', 'o') //"striog"
===
> 'stringH2'.replace(/(\w*)H\d/, '$1'); //"string"
===
> "John Smith".replace(/(\w+)\s(\w+)/, "$2, $1"); //"Smith, John".
===
> 'borderTop'.replace(/[A-Z]/, function(match) {return '-' + match.toLowerCase();});
// "border-top"
===
> 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, function(match, p1, p2, p3, offset, string) { return [match, p1, p2, p3].join(' - '); });
// "abc12345#$*% - abc - 12345 - #$*%"
// p1, p2, p3 are (the-groups) inside regexp
===
//replace-all
'monopoly'.replace('o', 'a') //"manopoly"
'monopoly'.replace(/o/g, 'a') //"manapaly"
'monopoly'.split('o').join('a') //"manapaly"

String.prototype.split-function

description::
The split() method splits a String object into an array of strings by separating the string into substrings, using a specified separator string to determine where to make each split.
Syntax
str.split([separator[, limit]])
Attention: If an empty string ("") is used as the separator, the string is not split between each user-perceived character (grapheme cluster) or between each unicode character (codepoint) but between each UTF-16 codeunit. This destroys surrogate pairs. See also How do you get a string to a character array in JavaScript? on stackoverflow.
Parameters
separator Optional
Specifies the string which denotes the points at which each split should occur. The separator is treated as a string or as a regular expression. If a plain-text separator contains more than one character, that entire string must be found to represent a split point. If separator is omitted or does not occur in str, the array returned contains one element consisting of the entire string. If separator is an empty string, str is converted to an array of characters. If no separator is specified, an array containing the input string is returned.
limit Optional
Integer specifying a limit on the number of splits to be found. When this parameter is provided, the split() method splits the string at each occurrence of the specified separator but stops when limit entries have been placed into the array. It may still contain fewer entries than limit if the end of the string is reached before the specified limit is reached. The left-over text is not returned in the new array.
Return value
An Array of strings split at each point where the separator occurs in the given string.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split]

name::
* McsEngl.lagJsgn'split-function,
* McsEngl.Jsf.split-of-string,
* McsEngl.split-function.string//Javascript,
* McsEngl.String.prototype.split-function,

example::
'Jan,Feb,Mar'.split(',') //["Jan", "Feb", "Mar"]
'Jan,Feb,Mar'.split(',', 2) //["Jan", "Feb"]
'Fred Barney; Helen Rigby ; Bill Abel'.split(/\s*;\s*/)
//["Fred Barney", "Helen Rigby", "Bill Abel"]
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split]

String.prototype.substring-function

name::
* McsEngl.lagJsgn'substring-function,
* McsEngl.Jsf.substring-of-string,
* McsEngl.String.prototype.substring-function,
* McsEngl.substring-function--of--Javascript-string,

Code::
> "nameXyz".substring(2) //meXyz
> s="nameXyz"; s.substring(s.indexOf('m')) //meXyz
> s="nameXyzXa"; s.substring(s.lastIndexOf('X')) //Xa
> "nameXyz".substring(2,4) //me
> "nameXyz".substring(0,2) //na
> s="name#12Xyz"; s.substring(s.search(/[#X]/)) //#12Xyz
> s="name12Xyz"; s.substring(s.search(/[#X]/)) //Xyz

Jsmwo'member

description::
The-members of the-most-whole-object are-called ALSO 'globals'.
To avoid ambiguity I will-call them 'global-members'.

name::
* McsEngl.Jsglobal,
* McsEngl.Jsmwo'global-member!⇒Jsglobal,
* McsEngl.lagJsgn'global-member!⇒Jsglobal,
* McsEngl.lagJsgn'globals!⇒Jsglobal,
* McsEngl.lagJsgn'member-of-most-whole-object!⇒Jsglobal,

specific::
* Jsbr-global-member,
* Jsnd-global-member,

Jsmwo'whole-part-tree

description::
The-semantic-units of an-api form a-whole-part-tree.
The-ROOT-node of this structure is the-most-whole-object (the-global-object) and contains all others.

name::
* McsEngl.JsAPI'whole-part-tree,
* McsEngl.Jsmwo'whole-part-tree,
* McsEngl.lagJsgn'whole-part-tree-of-API,
* McsEngl.lagJsgn'Wpt-API(Javascript--whole-part-tree-API),

specific::
* Jsbr-native-whole-part-tree,
* Jsnd-native-whole-part-tree,

Object-function

description::
Object is the-constructor that contains the-Object.prototype.
It can-create objects: var s = new Object('string');
It contains important members.

name::
* McsEngl.lagJsgn'Object-function,

whole-chain::
* most-whole-object,

generic-chain::
* Function.prototype,
* Object.prototype,

member::
(Chrome.50):
> Object.getOwnPropertyNames(Object).sort()
["arguments", "assign", "caller", "create", "defineProperties", "defineProperty", "freeze", "getOwnPropertyDescriptor", "getOwnPropertyNames", "getOwnPropertySymbols", "getPrototypeOf", "is", "isExtensible", "isFrozen", "isSealed", "keys", "length", "name", "preventExtensions", "prototype", "seal", "setPrototypeOf"]
(Firefox.46):
> Object.getOwnPropertyNames(Object).sort()
[]
(Edge.20):
> Object.getOwnPropertyNames(Object).sort()
[]
(Safari.5-1-7):
> Object.getOwnPropertyNames(Object).sort()
[]

specific::
* none,

jsAPI'generic-specific-tree

description::
The-semantic-units of an-api except of a-whole-part-tree form AND a-generic-specific-tree.
The-ROOT-node of this structure is the-most-generic-object, the-Object.prototype.

name::
* McsEngl.JsAPI'generic-specific-tree,
* McsEngl.lagJsgn'generic-specific-tree-of-API,

specific::
* Jsbr-native-generic-specific-tree,
* Jsnd-native-generic-specific-tree,

lagJsgn'Error-function

Description:
The Error constructor creates an error object. Instances of Error objects are thrown when runtime errors occur. The Error object can also be used as a base object for user-defined exceptions. See below for standard built-in error types.
Syntax
new Error([message[, fileName[, lineNumber]]])
[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Error]

name::
* McsEngl.Error-function//Javascript,
* McsEngl.lagJsgn'Error-function,
* McsEngl.Jsf.Error,

description::
All JavaScript and System errors raised by Node.js inherit from, or are instances of, the standard JavaScript Error class and are guaranteed to provide at least the properties available on that class.
[https://nodejs.org/docs/v6.3.1/api/errors.html#errors_errors]

member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(Error).sort()
[ 'arguments', 'caller', 'captureStackTrace', 'length', 'name', 'prototype', 'stackTraceLimit' ]
===
// Chrome.52
// Object.getOwnPropertyNames(Error).sort()
["arguments", "caller", "captureStackTrace", "length", "name", "prototype", "stackTraceLimit"]
===
// Firefox.47
// Object.getOwnPropertyNames(Error).sort()
[ "length", "name", "prototype" ]
===
// Edge.25
// Object.getOwnPropertyNames(Error).sort()
["arguments", "caller", length", "name", "prototype", "stackTraceLimit"]

addressWpg::
* https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Error,
* https://nodejs.org/api/errors.html,
* {2018-05-16} Brandon-Morelli, Top 10 JavaScript errors from 1000+ projects (and how to avoid them), https://codeburst.io/,

specific::
* EvalError,
* InternalError,
* RangeError,
* ReferenceError,
* SyntaxError,
* TypeError,
* URIError,

lagJsgn'JSON-object

description::
The-Javascript-JSON-object contains 2 functions that map Javascript-semantic-units with JSON-language-semantic-units, eg {a:1, b:2} <==> {"a":1,"b":2}

name::
* McsEngl.JSON-object//Javascript,
* McsEngl.lagJsgn-JSON-object,
* McsEngl.Jso.JSON,

whole-chain::
* lagJsgn-most-whole-object (global),

lagJsJSON'API:
(Chrome.55)
> Object.getOwnPropertyNames(JSON).sort().join(', ')
"parse, stringify"
> Object.getOwnPropertyNames(JSON.__proto__).sort().join(', ')
"__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf"

lagJsgn'Math-object

name::
* McsEngl.lagJsgn'Math-object,
* McsEngl.Jso.Math,
* McsEngl.Math-object//Javascript,

whole-chain::
* lagJsgn-most-whole-object (global),

lagJsMath'member::
(Jsnd.6-2-2)
> Object.getOwnPropertyNames(Math).sort()
[ 'E', 'LN10', 'LN2', 'LOG10E', 'LOG2E', 'PI', 'SQRT1_2', 'SQRT2', 'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'clz32', 'cos', 'cosh', 'exp', 'expm1', 'floor', 'fround', 'hypot', 'imul', 'log', 'log10', 'log1p', 'log2', 'max', 'min', 'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc' ]
(Firefox.47)
> Object.getOwnPropertyNames(Math).sort()
[ 'E', 'LN10', 'LN2', 'LOG10E', 'LOG2E', 'PI', 'SQRT1_2', 'SQRT2', 'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'clz32', 'cos', 'cosh', 'exp', 'expm1', 'floor', 'fround', 'hypot', 'imul', 'log', 'log10', 'log1p', 'log2', 'max', 'min', 'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'toSource', 'trunc' ]
(Edge.25)
> Object.getOwnPropertyNames(Math).sort()
[ 'E', 'LN10', 'LN2', 'LOG10E', 'LOG2E', 'PI', 'SQRT1_2', 'SQRT2', 'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'clz32', 'cos', 'cosh', 'exp', 'expm1', 'floor', 'fround', 'hypot', 'imul', 'log', 'log10', 'log1p', 'log2', 'max', 'min', 'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc' ]

lagJsgn'Set-function

description::
· the-Set-function create objects that contain not indexed data, only once.
· it is the-math-set-concept, in Javascript.
[hmnSngo.2018-07-09]
===
The Set object lets you store unique values of any type, whether primitive values or object references.
Syntax
new Set([iterable]);
Parameters
iterable: If an iterable object is passed, all of its elements will be added to the new Set. If you don't specify this parameter, or its value is null, the new Set is empty.
Return value
A new Set object.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set]

name::
* McsEngl.JsAPI'Set-function!⇒Jsset,
* McsEngl.Jsset,
* McsEngl.lagJsgn'Set-function!⇒Jsset,
* McsEngl.set//Javascript!⇒Jsset,

example::
var oSet = new Set([1,2,3]) //set with elements 1, 2, 3
var oSet2 = new Set('Hellas') //set with elements 'H' 'e', 'l', 'a', 's'

addressWpg::
* {2018-01-24} Maya-Shavin, ES6 — Set vs Array — What and when? https://medium.com/front-end-hacking/,

lagJsgn'console-object

description::
The Console object provides access to the browser's debugging console (e.g. the Web Console in Firefox). The specifics of how it works varies from browser to browser, but there is a de facto set of features that are typically provided.
The Console object can be accessed from any global object. Window on browsing scopes and WorkerGlobalScope as specific variants in workers via the property console. It's exposed as Window.console, and can be referenced as simply console.
[https://developer.mozilla.org/en-US/docs/Web/API/console]

name::
* McsEngl.lagJsgn'console-object,
* McsEngl.Jso.console,
* McsEngl.JsAPI'console-object,

example::
console.log('text') //text
console.log('do %s -> %s', 'str1', 'str2') //do str1 -> str2

member::
//Chrome.66
> Object.getOwnPropertyNames(console).sort().join(', ')
"assert, clear, context, count, debug, dir, dirxml, error, group, groupCollapsed, groupEnd, info, log, markTimeline, memory, profile, profileEnd, table, time, timeEnd, timeStamp, timeline, timelineEnd, trace, warn"

lagJsgn'decodeURI-function

description::
The decodeURI() function decodes a Uniform Resource Identifier (URI) previously created by encodeURI or by a similar routine.
Syntax
decodeURI(encodedURI)
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURI]

name::
* McsEngl.decodeURI-function//Javascript,
* McsEngl.lagJsgn'decodeURI-function,

code.Jsgn::
> decodeURI('https://el.wikipedia.org/wiki/
%CE%91%CE%BB%CE%AD%CE%BA%CE%BF%CF%82_%CE%86%CF%87%CE%BF%CE%BB%CE%BF%CF%82')
< "https://el.wikipedia.org/wiki/Αλέκος_Άχολος"

Resource:

Promise-function of Jspromise

description::
The core idea behind promises is that a promise represents the result of an asynchronous operation. A promise is in one of three different states:
pending - The initial state of a promise.
fulfilled - The state of a promise representing a successful operation.
rejected - The state of a promise representing a failed operation.
Once a promise is fulfilled or rejected, it is immutable (i.e. it can never change again).
[https://www.promisejs.org/]

name::
* McsEngl.Jspromise'Promise-function,
* McsEngl.Promise-function//Javascript,
* McsEngl.lagJsgn'Promise-function,

member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(Promise).sort()
[ 'accept', 'all', 'defer', 'length', 'name', 'prototype', 'race', 'reject', 'resolve' ]
// Object.getOwnPropertyNames(Promise.prototype).sort()
[ 'catch', 'chain', 'constructor', 'then' ]
===
// Chrome.52
// Object.getOwnPropertyNames(Promise).sort()
["all", "length", "name", "prototype", "race", "reject", "resolve"]
// Object.getOwnPropertyNames(Promise.prototype).sort()
[ 'catch', 'constructor', 'then' ]

info-resource of Jspromise

description::
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise,
* https://promisesaplus.com/,
===
{2017-10-31} Brandon-Morelli, JavaScript: Learn Promises, https://codeburst.io/Javascript-learn-promises-f1eaa00c5461,

name::
* McsEngl.Jspromise'resource,

DOING of Jspromise

description::
* completed:
** resolved,
** rejected,
* completedNo,

name::
* McsEngl.Jspromise'doing,

Jsgndef.FUNCTION

description::
A-sentence that creates function instance.
· Jscode:
function fName(input-variables) {
 //function body
}

name::
* McsEngl.Jsf'declaration,
* McsEngl.Jsf'definition-sentence,
* McsEngl.lagJsgn'definition.function,

Jsgndef.NAME-VALUE-PAIR

description::
· a-sentence that creates a-semantic-unit with a-reference-name.
· Jscode:
var n;
var n = 3;
const n = 3;
let n = 3;

name::
* McsEngl.lagJsgn'definition.Variable,
* McsEngl.lagJsgn'name-value-pair-definition,
* McsEngl.lagJsgn'variable-declaration,
* McsEngl.lagJsgn'variable-definition-sentence,
* McsEngl.lagJsgn'variable-statement,

generic-chain::
* Definition-sentence,

Jsloop.SPECIFIC

description::
* array.forEach,
* for,
* for..in,
* for..of,
* while,
* do..while,

name::
* McsEngl.Jsloop.specific,

Jsloop.for

description::
for (let n=0; n<9; n++) {
 //do something
}

name::
* McsEngl.Jsloop.for,

Jsloop.for..in-object

description::
const object = { a: 1, b: 2, c: 3 };
for (const property in object) {
 console.log(`${property}: ${object[property]}`);
}

name::
* McsEngl.Jsloop.for..in-object,

Jsloop.for..of

description::
const iterable = [10, 20, 30];
for (let value of iterable) {
 //do something
}

name::
* McsEngl.Jsloop.for..of-array,

Jsloop.while

description::
while (true) {
 //do something
}

name::
* McsEngl.Jsloop.while,

Jsloop.do..while

description::
do {
 //do something
} while (true)

name::
* McsEngl.Jsloop.do..while,

Jsaalgo.Array-of-array.INCLUDES

Code::
//returns the-index of array-part or -1
function fArray_includes_array(aWhole, aPart){
 var nI, nJ, aCurrent;
 for(nI = 0; nI < aWhole.length; ++nI){
   if(aPart.length === aWhole[nI].length){
     aCurrent = aWhole[nI];
     for(nJ = 0; nJ < aPart.length && aPart[nJ] === aCurrent[nJ]; ++nJ);
     if(nJ === aPart.length)
       return nI;
   }
 }
 return -1;
}
[https://stackoverflow.com/a/19543566]

name::
* McsEngl.Array-of-array.includes//Javascript,
* McsEngl.lagJsgn'array-of-array.includes,
* McsEngl.Jsaalgo.array-of-array.includes,

Jsaalgo.Array-of-array-primities.Remove-duplicates

Code::
function fArrayRemoveDupl(aIn) {
 //aIn = [[1,2],[3,4],[1,2],[1,3]]
 //aOut = [[1,2],[3,4],[1,3]]
 var
   aHelp = [],
   aOut = [],
   sElt;

 for(var n = 0; n < aIn.length; n++) {
   sElt = aIn[n].join('|');
   if(!aHelp.includes(sElt)) {
     aHelp.push(sElt);
     aOut.push(aIn[n]);
   }
 }
 return aOut;
}

name::
* McsEngl.Array-of-array-primitives.remove-duplicates//Javascript,
* McsEngl.lagJsgn'array-of-array-primitives.remove-duplicates,
* McsEngl.Jsaalgo.array-of-array-primitives.remove-duplicates,

Jsaalgo.Array-of-array.Sort

Code::
//a = [[1,2],[3,4],[2,2],[1,3]]
//sort on first element: [[1,2],[1,3],[2,2],[3,4]]
a.sort(fCompare1);
function fCompare1(aA, aB) {
 return aA[0] > aB[0] ? 1 : -1;
}
or
a.sort( (aA, aB) => {
 return aA[0] > aB[0] ? 1 : -1
})
===
//sort on second element: [[1,2],[2,2],[1,3],[3,4]]
a.sort(fCompare2);
function fCompare2(aA, aB) {
 return aA[1] > aB[1] ? 1 : -1;
}

name::
* McsEngl.Array-of-array.sort//Javascript,
* McsEngl.lagJsgn'array-of-array.sort//Javascript,
* McsEngl.Jsaalgo.array-of-array.sort//Javascript,

Jsalgo.date.YYYY-MM-DD

Jsalgo.Jsgn:::
function fDateYMD() {
 var
   oD, sY, sM, sD;
 oD = new Date();
 sY = oD.getFullYear().toString();
 sM = (oD.getMonth() + 1).toString();
 if (sM.length === 1) {
   sM = "0" + sM;
 }
 sD = oD.getDate().toString();
 if (sD.length === 1) {
   sD = "0" + sD;
 }
 return sY + "-" + sM + "-" + sD;
}

name::
* McsEngl.lagJsgn'date.YYYY-MM-DD,
* McsEngl.Jsalgo.date.YYYY-MM-DD,

Jsalgo.NUMBER

description::

Number.isInteger(123) //true
Number.isInteger('123') //false
Number('000123') //123
Number.isInteger(Number('123')) //true

(12).toString().padStart(6, "0") //'000012'
(12).toString().length //2


name::
* McsEngl.Jsalgo.number,
* McsEngl.number-managing//Javascript,

Jsalgo.HEX-TO-INT

example::
//hexadecimal to decimal
parseInt("ffff", 16) //65535

name::
* McsEngl.hex-to-int//Javascript,
* McsEngl.hexadecimal-to-decimal//Javascript,
* McsEngl.lagJsgn'hexadecimal-to-decimal,
* McsEngl.lagJsgn'hex-to-int,
* McsEngl.Jsalgo.hex-to-int,

Jsalgo.INT-TO-HEX

example::
//decimal to hexadecimal
(65535).toString(16) //ffff
//or if number is string
Number('65535').toString(16) //ffff

name::
* McsEngl.decimal-to-hexadecimal//Javascript,
* McsEngl.int-to-hex//Javascript,
* McsEngl.lagJsgn'decimal-to-hexadecimal,
* McsEngl.lagJsgn'int-to-hex,
* McsEngl.Jsalgo.int-to-hex,

Jsalgo.object.EQUALITY

Jsalgo.Jsgn:::
[1,3] === [1,3] //false
a = [1,3]
b = [1,3]
a === b //false
c = a
a === c //true
a == c //true

name::
* McsEngl.lagJsgn'object-equality,
* McsEngl.Jsalgo.object-equality,

Jsalgo.object.FIND-KEY-BY-VALUE

Jsalgo.Jsgn:::
//input: object, value
//output: key of value
function fObjvalRKey(oIn, valIn) {
 return Object.keys(oIn).find(
   function(key){
     return oIn[key] === valIn
   }
 );
}

name::
* McsEngl.lagJsgn'object-find-key-by-value,
* McsEngl.Jsalgo.object-find-key-by-value,

Jsalgo.object.MEMBER-COUNTING

Jsalgo.Jsgn:::
Object.keys(o).length

name::
* McsEngl.lagJsgn'object-member-counting,
* McsEngl.Jsalgo.object-member-counting,

Jsalgo.object.MEMBER-DELETING

Jsalgo.Jsgn:::
var o = {a:1, b:2};
var mbr = 'a';
delete o[mbr];
delete o['a'];
delete o.a

name::
* McsEngl.lagJsgn'object-key-deleting,
* McsEngl.lagJsgn'object-member-deleting,
* McsEngl.Jsalgo.object-member-deleting,

Jsalgo.object.MEMBER-EXISTANCE

Jsalgo.Jsgn:::
var o = {a:1, b:2};
'a' in o //true, search IN ITS GENERIC-CHAIN
o.hasOwnProperty('a') //true, search NOT in generic-chain

name::
* McsEngl.lagJsgn'object-key-existance,
* McsEngl.lagJsgn'object-member-existance,
* McsEngl.Jsalgo.object-member-existance,

Jsalgo.object.MEMBER-SORTING

Jsalgo.Jsgn:::
All methods that iterate over property keys do so in the same order:
- First all Array indices, sorted numerically.
- Then all string keys (that are not indices), in the order in which they were created.
- Then all symbols, in the order in which they were created.
So yes, JavaScript objects are in fact ordered, and the order of their keys/properties can be changed.

Here’s how you can sort an object by its keys/properties, alphabetically:

const unordered = {
 'b': 'foo',
 'c': 'bar',
 'a': 'baz'
};

console.log(JSON.stringify(unordered));
// → '{"b":"foo","c":"bar","a":"baz"}'

const ordered = {};
Object.keys(unordered).sort().forEach(function(key) {
 ordered[key] = unordered[key];
});

console.log(JSON.stringify(ordered));
// → '{"a":"baz","b":"foo","c":"bar"}'
Use var instead of const for compatibility with ES5 engines.
[https://stackoverflow.com/a/31102605]

name::
* McsEngl.lagJsgn'object-member-sorting,
* McsEngl.Jsalgo.object-member-sorting,

lagJsgn'simplicity

Its code is-created FROM only 12 semantic-units.

lagJsgn'inheritance

Javascript-objects do-not-inherit members from other special constructs like 'classes' (like java), but just from other objects.
This simple and powerful characteristic, called 'prototype-based-inheritance' confused programers who knew 'class-based-inheritance'.
Another cause of this confusion is the incorrect use of 'instanceof' by the-language designers.
Also constructor-functions mimic classes, especially with the-new-operator.
I have-created a full desktop browser program, which does-NOT-use a-single custom-constructor!!!
ECMAScript.6.2015 decision to add and classes, is wrong, because it creates an EXTRA semantic-unit, the-class, to implement inheritance[1] which[1] is already implemented with the-prototype-system.
Node.js implementation of 'classes' is-done by creating special functions.

name::
* McsEngl.inheritance//Javascript,
* McsEngl.lagJsgn'inheritance,

addressWpg::
* {2015-04-17} Eric Elliott: https://medium.com/Javascript-scene/common-misconceptions-about-inheritance-in-Javascript,

lagJsgn'naming-mechanism

Today builtin identifiers do-not-convey information about their values.
Since {2014.08.05}, I am-using valuenames in my code, which makes the-code much more readable.
Also this way we can-have type checking at write-time.

lagJsgn'instanceof

description::
'Instance' is a-specific-concept with no more specifics.
'My-car' is an-instance of 'car'.
lagJsgn-objects-created-from-constructors ARE NOT INSTANCES of their constructor.
They are instances of the-Constructor.prototype-object.
THEN the-instanceof operator is a design name-mistake of Javascript.
The-confusion came from class-based-languages where the-objects are indeed instances of classes.
objectof is a better name.

[https://twitter.com/BrendanEich/status/734118379036934144]

name::
* McsEngl.Jsgnopr.instanceof,
* McsEngl.lagJsgn'instanceof,
* McsEngl.instanceof//Javascript,

lagJsgn'object-scope

description::
Today, Jsgn, has only 'function-scope'.
This means, that a-name-value-pair defined inside a-function, can be used all over inside this function.
In other names, the-members of a-function see each other.
We do-not-have this feature inside objects, and to overcome it, we use constructors, or object-returning-functions.
· code-example:
var o = {n1:1, n2:n1} //throws Uncaught ReferenceError
var f=function(){var n1=1; var n2=n1;} //no Error

name::
* McsEngl.Jso'scope,

Jses.SPECIFIC

Specific (versions):
· https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
* ECMAScript.11.2020, (ES11)
* ECMAScript.10.2019, (ES10)
* ECMAScript.9.2018, (ES9)
* ECMAScript.8.2017 (ES8),
* ECMAScript.7.2016 (ES7),
* ECMAScript.6.2015 (ES6),
* ECMAScript.5-1.2011 (ES51),
* ECMAScript.5.1999 (ES5),
* ECMAScript.4 not existing (ES4),
* ECMAScript.3.1999 (ES3),
* ECMAScript.2.1998 (ES2),
* ECMAScript.1.1997 (ES1),

Jses.ECMAScript.11.2020

description::
· https://262.ecma-international.org/11.0/
· https://github.com/tc39/ecma262,
"This specification, the 11th edition, introduces the matchAll method for Strings, to produce an iterator for all match objects generated by a global regular expression; import(), a syntax to asynchronously import Modules with a dynamic specifier; BigInt, a new number primitive for working with arbitrary precision integers; Promise.allSettled, a new Promise combinator that does not short-circuit; globalThis, a universal way to access the global this value; dedicated export * as ns from 'module' syntax for use within modules; increased standardization of for-in enumeration order; import.meta, a host-populated object available in Modules that may contain contextual information about the Module; as well as adding two new syntax features to improve working with “nullish” values (null or undefined): nullish coalescing, a value selection operator; and optional chaining, a property access and function invocation operator that short-circuits if the value to access/invoke is nullish."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.11.2020!⇒ES2020,
* McsEngl.ES2020,
* McsEngl.ES2020-ES11!⇒ES2020,
* McsEngl.ES11!⇒ES2020,
* McsEngl.Jses.ECMAScript.11.2020!⇒ES2020,

Jses.ECMAScript.10.2019

description::
· https://262.ecma-international.org/10.0/
"ECMAScript 2019 introduced a few new built-in functions: flat and flatMap on Array.prototype for flattening arrays, Object.fromEntries for directly turning the return value of Object.entries into a new Object, and trimStart and trimEnd on String.prototype as better-named alternatives to the widely implemented but non-standard String.prototype.trimLeft and trimRight built-ins. In addition, it included a few minor updates to syntax and semantics. Updated syntax included optional catch binding parameters and allowing U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH SEPARATOR) in string literals to align with JSON. Other updates included requiring that Array.prototype.sort be a stable sort, requiring that JSON.stringify return well-formed UTF-8 regardless of input, and clarifying Function.prototype.toString by requiring that it either return the corresponding original source text or a standard placeholder."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.10.2019!⇒ES2019,
* McsEngl.ES2019,
* McsEngl.ES2019-ES10!⇒ES2019,
* McsEngl.ES10!⇒ES2019,
* McsEngl.Jses.ECMAScript.10.2019!⇒ES2019,

Jses.ECMAScript.9.2018

description::
· https://262.ecma-international.org/9.0/
"ECMAScript 2018 introduced support for asynchronous iteration via the AsyncIterator protocol and async generators. It also included four new regular expression features: the dotAll flag, named capture groups, Unicode property escapes, and look-behind assertions. Lastly it included object rest and spread properties."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.9.2018!⇒ES2018,
* McsEngl.ES2018,
* McsEngl.ES2018-ES9!⇒ES2018,
* McsEngl.ES9!⇒ES2018,
* McsEngl.Jses.ECMAScript.9.2018!⇒ES2018,

Jses.ECMAScript.8.2017

description::
· https://262.ecma-international.org/8.0/
Pdf-version.
HML-version.
""
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.8.2017!⇒Jses2017,
* McsEngl.ECMA-262-8th-edition!⇒Jses2017,
* McsEngl.ES2017-ES8!⇒Jses2017,
* McsEngl.ES.8.2017!⇒Jses2017,
* McsEngl.ES8-(ES.2017)!⇒Jses2017,
* McsEngl.Jses.8.2017!⇒Jses2017,
* McsEngl.Jses2017,
* McsEngl.Jses2017!=ECMA.262.8-edition,
* McsEngl.Standard.ECMA.262.8-edition!⇒Jses2017,

addressWpg::
* {2018-01-17} Justin-Michot, ES8 What’s New in JavaScript?, https://medium.com/@jsmichot/,

new-attributes::
* async-functions,
* string-padding (padStart, padEnd),
* Object.values(obj) & Object.entries(obj),
* object-descriptors,
* SharedArrayBuffer-object,

Jses.ECMAScript.7.2016

description::
· https://262.ecma-international.org/7.0/,
Pdf-version.
HML-version.
"ECMAScript 2016 was the first ECMAScript edition released under Ecma TC39's new yearly release cadence and open development process. A plain-text source document was built from the ECMAScript 2015 source document to serve as the base for further development entirely on GitHub. Over the year of this standard's development, hundreds of pull requests and issues were filed representing thousands of bug fixes, editorial fixes and other improvements. Additionally, numerous software tools were developed to aid in this effort including Ecmarkup, Ecmarkdown, and Grammarkdown. ES2016 also included support for a new exponentiation operator and adds a new method to Array.prototype called includes."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.7.2016!⇒Jses2016,
* McsEngl.ECMA-262-7th-edition!⇒Jses2016,
* McsEngl.ES2016-ES7!⇒Jses2016,
* McsEngl.ES7!⇒Jses2016,
* McsEngl.ES.7.2016!⇒Jses2016,
* McsEngl.Jses.7.2016!⇒Jses2016,
* McsEngl.Jses2016,
* McsEngl.Jses2016!=ECMA.262.7-edition,
* McsEngl.Standard.ECMA.262.7-edition!⇒Jses2016,

Jses.ECMAScript.6.2015

description::
· https://262.ecma-international.org/6.0/
* Pdf-version.
* HML-version.
· introduced: modules, classes.
===
"Focused development of the sixth edition started in 2009, as the fifth edition was being prepared for publication. However, this was preceded by significant experimentation and language enhancement design efforts dating to the publication of the third edition in 1999. In a very real sense, the completion of the sixth edition is the culmination of a fifteen year effort. The goals for this edition included providing better support for large applications, library creation, and for use of ECMAScript as a compilation target for other languages. Some of its major enhancements included modules, class declarations, lexical block scoping, iterators and generators, promises for asynchronous programming, destructuring patterns, and proper tail calls. The ECMAScript library of built-ins was expanded to support additional data abstractions including maps, sets, and arrays of binary numeric values as well as additional support for Unicode supplemental characters in strings and regular expressions. The built-ins were also made extensible via subclassing. The sixth edition provides the foundation for regular, incremental language and library enhancements. The sixth edition was adopted by the General Assembly of June 2015."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.6.2015!⇒Jses2015,
* McsEngl.ECMA-262-6th-edition!⇒Jses2015,
* McsEngl.ES2015-ES6!⇒Jses2015,
* McsEngl.ES6-(ES2015)!⇒Jses2015,
* McsEngl.ES.6.2015!⇒Jses2015,
* McsEngl.Jses.6.2015!⇒Jses2015,
* McsEngl.Jses2015,
* McsEngl.Jses2015!=ECMA.262.6-edition,
* McsEngl.standard.ECMA.262.6-edition!⇒Jses2015,

Compatibility:
* compatibility-table, Created by kangax,
* node.green, Node.js compatibility-table, Created by William-Kapke,

Jses.ECMAScript.5-1.2011

description::
· https://262.ecma-international.org/5.1/
My html5.id.toc.preview-version.
Pdf-version.
HML-version.
"The fifth edition was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as international standard ISO/IEC 16262:2011. Edition 5.1 of the ECMAScript Standard incorporated minor corrections and is the same text as ISO/IEC 16262:2011. The 5.1 Edition was adopted by the Ecma General Assembly of June 2011."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.5-1.2011!⇒Jses2011,
* McsEngl.ECMAScript-5.1!⇒Jses2011,
* McsEngl.ECMA-262-5.1-edition!⇒Jses2011,
* McsEngl.ES2011-ES5.1!⇒Jses2011,
* McsEngl.ES5.1!⇒Jses2011,
* McsEngl.ES.5-1.2011!⇒Jses2011,
* McsEngl.Jses.5-1.2011!⇒Jses2011,
* McsEngl.Jses2011,
* McsEngl.Jses!=ECMA.262.51-edition,
* McsEngl.standard.ECMA.262.51-edition!⇒Jses2011,

Jses.ECMAScript.5.1999b

description::
* ECMAScript.5.1999,
"After publication of the third edition, ECMAScript achieved massive adoption in conjunction with the World Wide Web where it has become the programming language that is supported by essentially all web browsers. Significant work was done to develop a fourth edition of ECMAScript. However, that work was not completed and not published as the fourth edition of ECMAScript but some of it was incorporated into the development of the sixth edition.
The fifth edition of ECMAScript (published as ECMA-262 5th edition) codified de facto interpretations of the language specification that have become common among browser implementations and added support for new features that had emerged since the publication of the third edition. Such features include accessor properties, reflective creation and inspection of objects, program control of property attributes, additional array manipulation functions, support for the JSON object encoding format, and a strict mode that provides enhanced error checking and program security. The fifth edition was adopted by the Ecma General Assembly of December 2009."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.5.1999b!⇒ES1999b,
* McsEngl.ES1999b,
* McsEngl.ES1999b-ES5!⇒ES1999b,
* McsEngl.ES5!⇒ES1999b,
* McsEngl.Jses.ECMAScript.5.1999b!⇒ES1999b,

Jses.ECMAScript.3.1999

description::
* ECMAScript.3.1999 (ES3),
"The third edition of the Standard introduced powerful regular expressions, better string handling, new control statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and minor changes in anticipation of future language growth. The third edition of the ECMAScript standard was adopted by the Ecma General Assembly of December 1999 and published as ISO/IEC 16262:2002 in June 2002."
[https://262.ecma-international.org/11.0/]

name::
* McsEngl.ECMAScript.3.1999!⇒ES1999,
* McsEngl.ES1999,
* McsEngl.ES1999-ES3!⇒ES1999,
* McsEngl.ES3!⇒ES1999,
* McsEngl.Jses.ECMAScript.3.1999!⇒ES1999,

Jses.ECMAScript.2.1998

description::
* ECMAScript.2.1998 (ES2),

name::
* McsEngl.ECMAScript.2.1998!⇒ES1998,
* McsEngl.ES1998,
* McsEngl.ES1998-ES2!⇒ES1998,
* McsEngl.ES2!⇒ES1998,
* McsEngl.Jses.ECMAScript.2.1998!⇒ES1998,

Jses.ECMAScript.1.1997

description::
* ECMAScript.1.1997,

name::
* McsEngl.ECMAScript.1.1997!⇒ES1997,
* McsEngl.ES1997,
* McsEngl.ES1997-ES1!⇒ES1997,
* McsEngl.ES1!⇒ES1997,
* McsEngl.Jses.ECMAScript.1.1997!⇒ES1997,

lagJsgn-runtime.SPECIFIC

specific::
* browser,
* Node.js-runtime,

info-resource of Jsgnengine

name::
* McsEngl.Jsgnengine'Infrsc,

addressWpg::
* {2017-02-28} Lin-Clark, A crash course in just-in-time (JIT) compilers, https://hacks.mozilla.org/2017/02/a-crash-course-in-just-in-time-jit-compilers/,

Jsgnengine.SPECIFIC

specific::
* browser-engine,
* browserNo-engine,
===
* Google-V8-engine,

Jsgnengine.SpiderMonkey

description::
SpiderMonkey is the code name for the first JavaScript engine, written by Brendan Eich at Netscape Communications, later released as open source and currently maintained by the Mozilla Foundation. SpiderMonkey provides JavaScript support for Mozilla Firefox and various embeddings such as the GNOME 3 desktop.
[https://en.wikipedia.org/wiki/SpiderMonkey]

name::
* McsEngl.Jsgnengine.SpiderMonkey,
* McsEngl.SpiderMonkey-Javascript-engine,

Jsgnengine.V8

description::
V8 is Google's open source high-performance JavaScript engine, written in C++ and used in Google Chrome, the open source browser from Google.
It implements ECMAScript as specified in ECMA-262, and runs on Windows XP or later, Mac OS X 10.5+, and Linux systems that use IA-32, ARM or MIPS processors.
V8 can run standalone, or can be embedded into any C++ application.
[https://github.com/v8/v8/wiki]

name::
* McsEngl.Google-V8-Javascript-engine,
* McsEngl.lagJsgn'V8,
* McsEngl.lagJsgn'Google-V8-engine,
* McsEngl.Jsgnengine.V8,
* McsEngl.V8--Javascript-engine,

pkgmgr.SPECIFIC

specific::
* bower-package-manager,
* npm-package-manager,

Jsgntool.DROME

description::
Drome project is my try to create JavaScript task runner which would be easy to use, lightweight, powerful and with well maintained ecosystem.
Features
⊛ Minimal abstraction: You can define tasks with command line statements and Node.js APIs
⊛ Independent: Drome doesn't have dependencies - it's really light and can grow up in his own way
⊛ Plug & play: All Node packages are Drome ecosystem - you don't have to wait for plugin updates
[https://github.com/dromejs/drome]

name::
* McsEngl.drome--task-runner,