structured-concept:
javascript-language (Ljs)

description of Ljs

description::
· javascript (ljs) is the GENERIC language of browser-javascript (ljb, client-side), Node-javascript (ljn, server-side), desktop-javascript (ljd) and other differentiations.

· javascript was originally developed in {1995} by Brendan-Eich, at Netscape-Communications-Corporation. [en.wikipedia.org]

· my goal here is my text to be MONOSEMANTIC as possible, in contrast to existing texts, by defining most of the-names of my sentences.
· ALSO, my text differs than the traditional one.
· I publish STRUCTURED-CONCEPTS|ModelConceptStructureds (MCS) in contrast to traditional text, that describes concepts.

· this is a living concept (= an evolving concept), see and reference by version.
· last-version is dynamic (do not reference with it), all others are static.
· even-though the-work I have-put on this webpage-concept is NOT a small amount, much more is-needed.

name::
* cpt.FilMcsLjs.Last.html,
* cpt.dirTchInf/FilMcsLjs.Last.html,
* cpt.Language.javascript-(Ljs),
* cpt.Ljs,
* cpt.Ljs'(LanguageJavaScript),
* cpt.Ljs-(LanguageJavaScript),
* cpt.JavaScript-(Ljs),
* cpt.javascript-(Ljs),
* cpt.Js-(Javascript|Ljs),

History-of-name:
Although it was developed under the name Mocha, the language was officially called LiveScript when it first shipped in beta releases of Netscape Navigator 2.0 in September 1995, but it was renamed JavaScript when it was deployed in the Netscape browser version 2.0B3.
The change of name from LiveScript to javascript roughly coincided with Netscape adding support for Java technology in its Netscape Navigator Web browser.
The final choice of name caused confusion, giving the impression that the language was a spin-off of the Java programming language, and the choice has been characterized as a marketing ploy by Netscape to give javascript the cachet of what was then the hot new Web programming language.

[https://en.wikipedia.org/wiki/javascript#Beginnings_at_Netscape]

"JavaScript" is a trademark of Oracle Corporation.
It is used under license for technology invented and implemented by Netscape Communications and current entities such as the Mozilla Foundation.

[https://en.wikipedia.org/wiki/JavaScript#Trademark]
===
THEN, JavaScript (with JS capital) is the-javascript of Mozilla.
I am-using the-names 'javascript' and 'ljs' for the generic language.
[HmnSgm.2016-07-22]

archetype of Ljs

description::
· all languages, human and computer, MAP (represent | translate) one entity (the-archetype) to another (model|code|algorithm), for a-communication reason.
· programing-languages map human-information-processing in a-format that machines can-process.
· Ljs-ARCHETYPE is a-document describing a-process of information as done by humans.
· a-programer MUST-KNOW an-archetype first, in order to create a-program.

name::
* cpt.javascript'archetype,
* cpt.javascript'problem,
* cpt.Ljs'archetype,
* cpt.Ljs'problem,

specific::
* Ljb-archetype,
* Ljn-archetype,

algorithm of Ljs

description::
· Ljs-algorithm is a-document describing the same process with an-Ljs-archetype as done by a-machine in ANY LANGUAGE.

name::
* cpt.javascript'algo,
* cpt.Ljs'algo,
* cpt.Ljs'algorithm,
* cpt.Ljs'model,
* cpt.Ljs'algo,
* cpt.Ljs'algorithm,
* cpt.Ljs'model,

description::
· in literature we see that "an-algorithm is a-process ...".
· I say an-algorithm is a-document that describes a-process.
· see the-analogy of cooking-recipe (algorithm) and cooking-process.
===
· an-algorithm is a-document with a whole-part-tree structure, the-syntax-tree, like all documents.
===
· a-program is a-document describing the same process with an-archetype written in a-programing-language a-machine understands.
· no matter how well someone speaks a-language, it is impossible to translate a-process[a] in this language, if first s|he does NOT know the-process[a] in his native language.
· the-programer first is-thinking the-algorithm in his native-natural-language, but translates it formats that machines understand.
· natural-language is a human-friendly format, but unfriendly for the-machines.
· flowchart, is a graphical format, like the natural-language format.
· source-code, is the-format that a-programing-language defines and abstract-machines understand, written by programers.
· binary-code is the-format that real-machines understand, written by machines.

specific::
* natural-language,
* flowchart,
* source-code,
* Web-IDL,
* binary-code,

source-document of Ljs (src-doc)

description::
The-code[1] is a-format of an-algorithm that is-understood both by humans and machines and it[1] is-defined by the-language.

name::
* cpt.code-of-Ljs,
* cpt.javascript'code,
* cpt.javascript'source-code,
* cpt.Ljs'code,
* cpt.Ljs'code-format,
* cpt.javascript'source-document,
* cpt.Ljs'source-document,
* cpt.Ljs'src-doc,
* cpt.Ljs'algo'code,
* cpt.Ljs'code,
* cpt.Ljs'src-doc,
* cpt.source-code--of-Ljs,
* cpt.script-of-Ljs,

src-doc'syntax-tree

description::
· THE-STRUCTURE of a-source-document is a-WHOLE-PART-TREE of units, semantic-units, phrases, sentences, sections of the-language which parts we define in the-next sections.
· this whole-part-tree is the-syntax-tree of the-source-document.
· in contrast, the-API of the-language, is structured in a-whole-part-tree and in a-generic-part-tree.
[HmnSgm.2018-03-02]

name::
* cpt.javascript'syntax-tree,
* cpt.javascript'syntax-tree,
* cpt.Ljs'syntax-tree,
* cpt.Ljs'syntax-whole-part-tree,
* cpt.syntax-tree--of-javascript,

src-doc'UNIT

description::
· in order to create an-algorithm in any format, we must use other entities[1], that[1] REPRESENT NOTHING in archetype and which[1] are INDIVISIBLE.
· these are the-units of the-algorithm, and the entire algorithm is a whole-part-tree system of constructs of these units.
· natural-languages use sounds or symbols.
· flowcharts use graphs.
· source-code uses the-Unicode character-set.
Ljb and Ljn use the same code-units.

name::
* cpt.javascript'unit,
* cpt.Ljs'algo'unit,
* cpt.Ljs'src-doc'unit,
* cpt.Ljs'unit,

src-doc'WORD (wrd)

description::
Words are combinations of units, that REPRESENT NOTHING, the-language uses to create whole constructs with meaning (= denote archetype).

name::
* cpt.Ljs'algo'word,
* cpt.javascript'word,
* cpt.Ljs'word,

src-doc'SEMANTIC-UNIT (sut)

description::
An-algorithm is a-document with a-whole-part-tree-structure created by combining simpler parts.
The-units (indivisible parts) that DENOTE ARCHETYPE, used to create an-algorithm, are the-semantic-units.
Programing-languages use different semantic-units and combinations of semantic-units to create algorithms that map the same archetype.

name::
* cpt.data-type.Ljs,
* cpt.data-structure.Ljs,
* cpt.javascript'semantic-unit,
* cpt.javascript'data-type,
* cpt.javascript'data-structure,
* cpt.javascript'semantic-unit,
* cpt.Ljs'data-type,
* cpt.Ljs'data-structure,
* cpt.Ljs'semantic-unit,
* cpt.Ljs'Sut,
* cpt.Ljs'Sunit,
* cpt.Ljs'untSmc,
* cpt.Ljs'unit.semantic,
* cpt.semantic-unit.javascript,

Whole-chain::
=== (syntax--whole-part-tree)
* Ljs-phrase,
* Ljs-sentence,
* Ljs-section,
* Ljs-library,
* Ljs-program,
=== (API--whole-part-tree)
* another semantic-unit,
...
* most-whole-object,

generic-chain::
* object,
or
* objectNo,

Part::
* Ljs-word,
* Ljs-unit,

Name-of-sut (identifier)

description::
Most semantic-units are anonymous.
Only a-function has name in one case.
The-code below, shows how we give names to semantic-units.
The-name we give to a-semantic-unit when we create a-variable, I call REFERENCE-NAME.
A-semantic-unit can have many reference-names.
The other name that a-semantic-unit can-have (as a-member of it) I call INTERNAL-NAME.

code.Ljs:::
> function f(){} //function with internal-name
> var f = function(){} //anonymous function, with reference-name
> var f = function f2(){} //function with internal and reference name
> [1,2] //anonymous array, lost in global
> var a = [1,2] //anonymous array, with reference-name
> a.name = 'sgm' //array with internal and reference name
> b = a //another reference-name for sgm-array
> c = b //another reference-name for sgm-array
> c.name //gives 'sgm'

name::
* cpt.javascript'name-of--semantic-unit,
* cpt.javascript'identifier,
* cpt.Ljs'identifier,
* cpt.Ljs'identifier,
* cpt.Ljs'internal-name-of-semantic-unit,
* cpt.Ljs'name-of-semantic-unit,
* cpt.Ljs'semantic-unit'name,
* cpt.name-of-semantic-unit.javascript,

sut-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::
* cpt.external-name--of--semantic-unit.javascript,
* cpt.javascript'reference,
* cpt.Ljs'reference,
* cpt.Ljs'semantic-unit'reference-name,
* cpt.Ljs'semantic-unit-name.external,
* cpt.Ljs'reference-name,
* cpt.Ljs'variable-name,
* cpt.Ljs'variable-reference,
* cpt.reference-name--of--semantic-unit.javascript,

sut-name.external.TYPENAME

description::
Valuename|typename is an-identifier which denotes its value|type.
Since {2014.08.05} I am-using typenames in my code, which makes the-code much more readable.

name::
* cpt.javascript'typename,
* cpt.Ljs'typename,
* cpt.Ljs'valuename,
* cpt.typename.javascript,
* cpt.valuename.javascript,

specific::
In javascript we need only 11 typenames to denote ALL its types:
01) aName for Arrays,
02) bName for Booleans,
03) fName for Functions,
04) lName for nuLl,
05) mName for Modules,
06) nName for Numbers,
07) oName for Objects,
08) rName for Regexps,
09) sName for Strings,
10) uName for Undefined,
11) xName for miXed-name-value-pairs,

sut-name.INTERNAL

description::
· a-semantic-unit can-have a-name which is a-member of it.
· I call it, INTERNAL-NAME.
> function f(){} //function with internal-name
> f.name // "f"

[HmnSgm.2018-01-06]

name::
* cpt.internal-name--of--semantic-unit.javascript,
* cpt.Ljs'semantic-unit'internal-name,
* cpt.Ljs'semantic-unit-name.Internal,

scope-of-sut

description::
· scope-of-a-semantic-unit is the-region of the-program in which it is accessible|visible.
· the-scope determines the-whole-part-tree-API.
· in other words, the-scope-of-a-semantic-unit is its whole-relation.
[HmnSgm.2018-01-05]

name::
* cpt.javascript'scope,
* cpt.Ljs'scope,
* cpt.scope-of--semantic-unit.javascript,

specific::
* block-scope,
* function-scope,
* object-scope,
* module-scope,

Ljs-Sut.SPECIFIC

specific::
Ljs uses only 11 semantic-units to create algorithms:
01) a - Array,
02) b - Boolean,
03) f - Function,
04) l - nuLl,
05) m - Module,
06) n - Number,
07) o - Object,
08) r - Regexp,
09) s - String,
10) u - Undefined,
11) x - miXed,

Specific.alphabetically::
* array--semantic-unit,
* boolean--semantic-unit,
* custom--semantic-unit,
* customNo--semantic-unit,
* function--semantic-unit,
* Ljb-semantic-unit,
* Ljn-semantic-unit,
* name-semantic-unit,
* nameNo-semantic-unit,
* name-value-pair-mixed--semantic-unit,
* name-value-pair-mixedNo--semantic-unit,
* name-value-pair-No--semantic-unit,
* null--semantic-unit,
* number--semantic-unit,
* object--semantic-unit,
* objectNo--semantic-unit,
* regexp--semantic-unit,
* string--semantic-unit,
* undefined--semantic-unit,

Ljs-Sut.Code

description::
Code-semantic-unit is a-semantic-unit written in code-format.

name::
* cpt.Ljs'semantic-unit.code,
* cpt.Ljs'semantic-unit.code,
* cpt.Ljs'code-semantic-unit,

Ljs-Sut.SPECIFIC-DIVISION.dialect

specific::
* Ljb-semantic-unit,
* Ljn-semantic-unit,

Ljs-Sut.SPECIFIC-DIVISION.object

specific::
* object-semantic-unit,
* objectNo-semantic-unit,

Ljs-Sut.objectNo

description::
objectNo is a-semantic-unit which is NOT object, it is NOT specific of Object.prototype.
Only 2 semantic-units are not objects: null, undefined.

name::
* cpt.Ljs'objectNo-semantic-unit,
* cpt.Ljs'Sut.objectNo,

Ljs-Sut.SPECIFIC-DIVISION.creator

specific::
* custom-semantic-unit,
* customNo-semantic-unit,

Ljs-Sut.Custom

description::
A-semantic-unit created by a-programer.

name::
* cpt.Ljs'builtinNo-semantic-unit,
* cpt.javascript'custom-semantic-unit,
* cpt.Ljs'custom-semantic-unit,
* cpt.javascript'nativeNo-semantic-unit,
* cpt.Ljs'nativeNo-semantic-unit,
* cpt.javascript'standardNo-semantic-unit,
* cpt.Ljs'standardNo-semantic-unit,
* cpt.Ljs'builtinNo-semantic-unit,
* cpt.Ljs'custom-semantic-unit,
* cpt.Ljs'nativeNo-semantic-unit,
* cpt.Ljs'standardNo-semantic-unit,
* cpt.Ljs'Sut.Custom,

Ljs-Sut.custom.OWN (dependencyNo)

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

name::
* cpt.javascript'customInternal-semantic-unit,
* cpt.Ljs'customInternal-semantic-unit,
* cpt.Ljs'customOwn-semantic-unit,
* cpt.Ljs'dependencyNo-semantic-unit,
* cpt.Ljs'dependentNo-semantic-unit,
* cpt.Ljs'independent-semantic-unit,
* cpt.Ljs'ownCustom-semantic-unit,
* cpt.Ljs'customInternal-semantic-unit,
* cpt.Ljs'customOwn-semantic-unit,
* cpt.Ljs'dependencyNo-semantic-unit,
* cpt.Ljs'dependentNo-semantic-unit,
* cpt.Ljs'independent-semantic-unit,
* cpt.Ljs'Sut.CustomOwn,

Ljs-Sut.custom.OWN.NO (dependency)

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

name::
* cpt.javascript'customExternal-semantic-unit,
* cpt.Ljs'customExternal-semantic-unit,
* cpt.Ljs'customOwnNo-semantic-unit,
* cpt.Ljs'dependency-semantic-unit,
* cpt.Ljs'dependent-semantic-unit,
* cpt.Ljs'independentNo-semantic-unit,
* cpt.Ljs'ownNoCustom-semantic-unit,
* cpt.Ljs'customExternal-semantic-unit,
* cpt.Ljs'customOwnNo-semantic-unit,
* cpt.Ljs'dependency-semantic-unit,
* cpt.Ljs'dependent-semantic-unit,
* cpt.Ljs'independentNo-semantic-unit,
* cpt.Ljs'ownNoCuston-semantic-unit,
* cpt.Ljs'Sut.CustomOwnNo,

Ljs-Sut.CustomNo (native)

description::
A-semantic-unit created by the-language-creator.

name::
* cpt.javascript'builtin-semantic-unit,
* cpt.Ljs'builtin-semantic-unit,
* cpt.Ljs'built-in-semantic-unit,
* cpt.Ljs'customNo-semantic-unit,
* cpt.Ljs'native-semantic-unit,
* cpt.Ljs'standard-semantic-unit,
* cpt.Ljs'builtin-semantic-unit,
* cpt.Ljs'built-in-semantic-unit,
* cpt.Ljs'customNo-semantic-unit,
* cpt.Ljs'native-semantic-unit,
* cpt.Ljs'standard-semantic-unit,
* cpt.Ljs'Sut.CustomNo,

Ljs-Sut.Internal

description::
A-semantic-unit created inside a-program|library.

name::
* cpt.javascript'exteranlNo-semantic-unit,
* cpt.Ljs'exteranlNo-semantic-unit,
* cpt.Ljs'internal-semantic-unit,
* cpt.Ljs'own-semantic-unit,
* cpt.Ljs'externalNo-semantic-unit,
* cpt.Ljs'internal-semantic-unit,
* cpt.Ljs'own-semantic-unit,

Ljs-Sut.InternalNo (external)

description::
A-semantic-unit created OUTSIDE of a-program|library, native or custom.

name::
* cpt.javascript'exteranal-semantic-unit,
* cpt.Ljs'exteranal-semantic-unit,
* cpt.Ljs'internalNo-semantic-unit,
* cpt.Ljs'ownNo-semantic-unit,
* cpt.Ljs'external-semantic-unit,
* cpt.Ljs'internalNo-semantic-unit,
* cpt.Ljs'ownNo-semantic-unit,

Ljs-Sut.SPECIFIC-DIVISION.reference

specific::
* referenced--semantic-unit,
* referencedNo--semantic-unit,

Ljs-Sut.REFERENCED

Created:: {2017-06-11}

description::
· referenced-semantic-unit is a-semantic-unit which HAS a-reference-name associated with it.
[HmnSgm.2018-01-07]

name::
* cpt.javascript'anonymousNo-semantic-unit,
* cpt.Ljs'anonymousNo-semantic-unit,
* cpt.Ljs'named-semantic-unit,
* cpt.Ljs'name-value-pair,
* cpt.Ljs'variable,
* cpt.Ljs'anonymousNo-semantic-unit,
* cpt.Ljs'referenced-semantic-unit,
* cpt.Ljs'named-semantic-unit,
* cpt.Ljs'Sut.Referenced,
* cpt.referenced-semantic-unit.javascript,
* cpt.variable.javascript,

* cpt.Ljs'SutRef,
* cpt.Ljs'variable,
* cpt.Ljs'Nvp,
* cpt.Ljs-v,

Name-of--Ljs-SutRef

description::
· the-external-name of a-referenced-semantic-unit.
[HmnSgm.2018-01-07]

Value-of--Ljs-SutRef

description::
The-information we assign in the-name of a-name-value-pair is-called value.

name::
* cpt.javascript'value,
* cpt.Ljs'value,
* cpt.Ljs'value,

definition-of--Ljs-SutRef (link)

Ljs-SutRef.SPECIFIC

specific::
=== SPECIFIC-DIVISION-on-different-type-of-values
* mixed--referenced-semantic-unit,
* mixedNo--referenced-semantic-unit,
=== SPECIFIC-DIVISION-on-one-value
* constant--referenced-semantic-unit,
* constantNo--referenced-semantic-unit,
===
* array-nvp (var a = []),
* boolean-nvp (var b = true),
* function-nvp (var f = function(){}),
* module-nvp (var m = require('os')),
* number-nvp (var n = 3),
* object-nvp (var o = {}),
* regexp-nvp (var r = /x/),
* string-nvp (var s = 'a-string'),

Ljs-Sut.referenced.MIXED (ljs-x)

description::
· mixed is a-name-value-pair that contains different semantic-units.
· this attribute makes the-javascript a-dynamic-language.
[HmnSgm.2018-01-07]

name::
* cpt.javascript'mixed--semantic-unit,
* cpt.Ljs'mixed--semantic-unit,
* cpt.Ljs'Sut.mixed,
* cpt.Ljs-x,
* cpt.mixed--semantic-unit--of-javascript-(Ljs-x),

Ljs-Sut.referenced.MIXED.NO

description::
· mixedNo-name-value-pair is a-name-value-pair which ASSOCIATES only ONE type of value with its-name.
[HmnSgm.2018-01-07]

name::
* cpt.javascript'mixedNo-name-value-pair--semantic-unit,
* cpt.Ljs'mixedNo-name-value-pair--semantic-unit,
* cpt.Ljs'mixedNo-semantic-unit,
* cpt.Ljs'mixedNo-sut,
* cpt.Ljs'mixedNo-semantic-unit,
* cpt.Ljs'mixedNo-name-value-pair--semantic-unit,
* cpt.Ljs'mixedNo-sut,

Ljs-Sut.referenced.CONSTANT

description::
The const declaration creates a read-only reference to a value.
It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned.
[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/const]

name::
* cpt.javascript'constant-name-value-pair,
* cpt.Ljs'constant-name-value-pair,
* cpt.Ljs'const-name-value-pair,
* cpt.Ljs'constant,

Ljs-Sut.referenced.CONSTANT.NO

description::
The scope of a variable declared with var is its current execution context, which is either the enclosing function or, for variables declared outside any function, global. [https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/var]

name::
* cpt.javascript'constantNo-name-value-pair,
* cpt.Ljs'constantNo-name-value-pair,

Ljs-Sut.REFERENCED.NO

description::
NameNo is a-semantic-unit which HAS NO a-name associated with it.

name::
* cpt.javascript'anonymous-semantic-unit,
* cpt.Ljs'anonymous-semantic-unit,
* cpt.Ljs'namedNo-semantic-unit,
* cpt.Ljs'referencedNo-semantic-unit,

Ljs-Sut.ARRAY (Ljs-a)

description::
· array is an-ordered-collection of other semantic-units.
Code-example:
var a = [true, 1, {n:1}, /d/, 's'];

name::
* cpt.array--semantic-unit--of-javascript-(Ljs-a),
* cpt.javascript'array--semantic-unit,
* cpt.Ljs'array--semantic-unit,
* cpt.Ljs'Sut.array,
* cpt.Ljs-a,
* cpt.Ljs-a-(javascript-array),
* cpt.Ljs'array,

generic-chain::
* Array.prototype, ([].__proto__ === Array.prototype //true)
* Object.prototype, ([].__proto__.__proto__ === Object.prototype //true)

Ljs-a'creating

description::
Code:
var a1 = [1, 's'];
//===
var a2 = new Array(1, 's');

name::
* cpt.Ljs-a'creation,
* cpt.Ljs'array'creation,

Ljs-a'element

description::
· elements|items are the-entities an-array contains.
To access them Ljs uses the-code:
a[nIndex]

name::
* cpt.javascript'array-element,
* cpt.Ljs'array-element,
* cpt.Ljs'array-item,
* cpt.Ljs-a'element,
* cpt.Ljs-a'item,

Ljs-a'index

description::
· index-of-array is a-number (starts with 0) that denotes the-order of one of its elements.

name::
* cpt.Ljs'array'index,
* cpt.Ljs-a'index,

Ljs-a'member

description::
· arrays are-considered objects of the-Array-constructor-function, with generic the-Array.prototype-object.
In other words, the-members-of-the-Array.prototype-object are-inherited by all arrays.
Also, any array[1] can-have extra members in addition to its[1] inherited members and to its[1] elements.
Code:
a.n = 3;

name::
* cpt.Ljs'array'member,
* cpt.Ljs-a'member,

Member::
// Chrome62 Object.getOwnPropertyNames([]).sort()).join(', '))
[length]
// Object.getOwnPropertyNames([].__proto__).sort()).join(', '))
[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]
// Object.getOwnPropertyNames([].__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljs-a'Array-function

description::
Array is a-built-in-function and is-considered the-constructor, of all arrays.
Then, Array.prototype is the-parent-generic-object of all arrays.

name::
* cpt.javascript'Array-constructor,
* cpt.Ljs'Array-constructor,
* cpt.Ljs'Array-function,
* cpt.Ljs-f.Array,

generic-chain::
* Function.prototype (Array.__proto__ === Function.prototype //true),
* Object.prototype (Array.__proto__.__proto__ === Object.prototype //true),

Ljs-a'Array.prototype

description::
Array.prototype[1] is the-generic-object, of all arrays.
In other words, its[1] members are-inherited by all arrays.

name::
* cpt.Array.prototype.javascript,
* cpt.javascript'Array.prototype-object,
* cpt.Ljs'Array.prototype-object,
* cpt.Ljs-o.Array.prototype,

generic-chain::
* Object.prototype (Array.prototype.__proto__ === Object.prototype //true),

Ljs'Array.prototype'Member

member::
Code
(ljn.622):
> 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"]

Ljs'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::
* cpt.Array.prototype.concat-function,
* cpt.Ljs-a'concat-function,
* cpt.javascript'concat-array-function,
* cpt.Ljs'concat-array-function,
* cpt.concat--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.copyWithin-function,
* cpt.Ljs-a'copyWithin-function,
* cpt.javascript'copyWithin-array-function,
* cpt.Ljs'copyWithin-array-function,
* cpt.copyWithin--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.entries-function,
* cpt.Ljs-a'entries-function,
* cpt.javascript'entries-array-function,
* cpt.Ljs'entries-array-function,
* cpt.entries--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.every-function,
* cpt.Ljs-a'every-function,
* cpt.javascript'every-array-function,
* cpt.Ljs'every-array-function,
* cpt.every--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.fill-function,
* cpt.Ljs-a'fill-function,
* cpt.javascript'fill-array-function,
* cpt.Ljs'fill-array-function,
* cpt.fill--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.filter-function,
* cpt.Ljs-a'filter-function,
* cpt.javascript'filter-array-function,
* cpt.Ljs'filter-array-function,
* cpt.filter--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.find-function,
* cpt.Ljs-a'find-function,
* cpt.javascript'find-array-function,
* cpt.Ljs'find-array-function,
* cpt.find--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.findIndex-function,
* cpt.Ljs-a'findIndex-function,
* cpt.javascript'findIndex-array-function,
* cpt.Ljs'findIndex-array-function,
* cpt.findIndex--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.forEach-function,
* cpt.forEach--javascript-array-function,
* cpt.Ljs-a'forEach-function,
* cpt.javascript'forEach-array-function,
* cpt.Ljs'forEach-array-function,

Ljs'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::
* cpt.Array.prototype.includes-function,
* cpt.Ljs-a'includes-function,
* cpt.javascript'includes-array-function,
* cpt.Ljs'includes-array-function,
* cpt.includes--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.indexOf-function,
* cpt.Ljs-a'indexOf-function,
* cpt.javascript'indexOf-array-function,
* cpt.Ljs'indexOf-array-function,
* cpt.indexOf--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.join-function,
* cpt.Ljs-a'join-function,
* cpt.javascript'join-array-function,
* cpt.Ljs'join-array-function,
* cpt.join--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.keys-function,
* cpt.Ljs-a'keys-function,
* cpt.javascript'keys-array-function,
* cpt.Ljs'keys-array-function,
* cpt.keys--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.lastIndexOf-function,
* cpt.Ljs-a'lastIndexOf-function,
* cpt.javascript'lastIndexOf-array-function,
* cpt.Ljs'lastIndexOf-array-function,
* cpt.lastIndexOf--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.length-number,
* cpt.Ljs-a'length-number,
* cpt.javascript'length-array-number-member,
* cpt.Ljs'length-array-number-member,
* cpt.length--javascript-array-number-member,

Ljs'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::
* cpt.Array.prototype.map-function,
* cpt.Ljs-a'map-function,
* cpt.javascript'map-array-function,
* cpt.Ljs'map-array-function,
* cpt.map--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.pop-function,
* cpt.Ljs-a'pop-function,
* cpt.javascript'pop-array-function,
* cpt.Ljs'pop-array-function,
* cpt.pop--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.push-function,
* cpt.Ljs-a'push-function,
* cpt.javascript'push-array-function,
* cpt.Ljs'push-array-function,
* cpt.push--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.reduce-function,
* cpt.Ljs-a'reduce-function,
* cpt.javascript'reduce-array-function,
* cpt.Ljs'reduce-array-function,
* cpt.reduce--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.reduceRight-function,
* cpt.Ljs-a'reduceRight-function,
* cpt.javascript'reduceRight-array-function,
* cpt.Ljs'reduceRight-array-function,
* cpt.reduceRight--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.reverse-function,
* cpt.Ljs-a'reverse-function,
* cpt.javascript'reverse-array-function,
* cpt.Ljs'reverse-array-function,
* cpt.reverse--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.shift-function,
* cpt.Ljs-a'shift-function,
* cpt.javascript'shift-array-function,
* cpt.Ljs'shift-array-function,
* cpt.shift--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.slice-function,
* cpt.Ljs-a'slice-function,
* cpt.javascript'slice-array-function,
* cpt.Ljs'slice-array-function,
* cpt.slice--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.some-function,
* cpt.Ljs-a'some-function,
* cpt.javascript'some-array-function,
* cpt.Ljs'some-array-function,
* cpt.some--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.sort-function,
* cpt.Ljs-a'sort-function,
* cpt.javascript'sort-array-function,
* cpt.Ljs'sort-array-function,
* cpt.sort--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.splice-function,
* cpt.Ljs-a'splice-function,
* cpt.javascript'splice-array-function,
* cpt.Ljs'splice-array-function,
* cpt.splice--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.toLocaleString-function,
* cpt.Ljs-a'toLocaleString-function,
* cpt.javascript'toLocaleString-array-function,
* cpt.Ljs'toLocaleString-array-function,

Ljs'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::
* cpt.Array.prototype.toString-function,
* cpt.Ljs-a'toString-function,
* cpt.javascript'toString-array-function,
* cpt.Ljs'toString-array-function,

Ljs'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::
* cpt.Array.prototype.unshift-function,
* cpt.Ljs-a'unshift-function,
* cpt.Ljs'unshift-array-function,
* cpt.unshift--javascript-array-function,

Ljs'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::
* cpt.Array.prototype.values-function,
* cpt.Ljs-a'values-function,
* cpt.javascript'values-array-function,
* cpt.Ljs'values-array-function,
* cpt.values--javascript-array-function,

Ljs-Sut.BOOLEAN (ljs-b)

description::
Boolean is any of the two semantic-units: false, true.

name::
* cpt.boolean--semantic-unit--of-javascript-(Ljs-b),
* cpt.javascript'boolean--semantic-unit,
* cpt.javascript'boolean--semantic-unit,
* cpt.Ljs'boolean--semantic-unit,
* cpt.Ljs'Sut.boolean,
* cpt.Ljs'boolean,
* cpt.Ljs-b,
* cpt.Ljs'boolean,

generic-chain::
* Boolean.prototype, (true.__proto__ === Boolean.prototype //true)
* Object.prototype, (true.__proto__.__proto__ === Object.prototype //true)

specific::
* false,
* true,

Ljs'Boolean.prototype

description::
Boolean.prototype is the-generic-object, of booleans.
In other words, its members are-inherited by booleans.

name::
* cpt.Ljs-o.Boolean.prototype,
* cpt.javascript'Boolean.prototype-object,
* cpt.Ljs'Boolean.prototype-object,

generic-chain::
* Object.prototype (Boolean.prototype.__proto__ === Object.prototype //true),

member::
(ljn.630):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
[ 'constructor', 'toString', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toString", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toSource", "toString", "valueOf"]

(Edge.20):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toString", "valueOf"]

(Safari.5-1-7):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toString", "valueOf"]

Ljs-Sut.FUNCTION (ljs-f)

description::
Function is the-semantic-unit that PROCESSES information.
Optionally has input and output.

name::
* cpt.Function--semantic-unit--of-javascript-(Ljs-f),
* cpt.javascript'function--semantic-unit,
* cpt.Ljs'function--semantic-unit,
* cpt.Ljs'Sut.function,
* cpt.Ljs-f,
* cpt.Ljs-f-(Javascript-function),
* cpt.Ljs'function,

Whole-chain::
* the-semantic-unit in which defined,
...
* most-whole-object,

generic-chain::
* Function.prototype, (var f = function(){}; f.__proto__ === Function.prototype //true)
* Object.prototype, (f.__proto__.__proto__ === Object.prototype //true)

Ljs-f'Creation

description::
With a-compound-sentence, we define|create a-function.
We define its input, output and what info-processing will-do.
Code:
function fName() { // inside parentheses we write the input identifiers
 //what to do
 //last, what to return
}

or
var fName = function() {
 //what to do
 //last, what to return
}

In the second case, we define one name-value-pair with name fName and value an anonymous function.

name::
* cpt.javascript'function-creation,
* cpt.Ljs'function-creation,
* cpt.Ljs'function-definition,
* cpt.Ljs-f'creation,
* cpt.Ljs-f'definition,

Ljs-f'Call

description::
Function-call is the-process of setting a-function to work.
We define a-function once, we call it as many times as we wish.
We use the next phrase, to call a-function.
Code:
fName()
Inside the-parentheses we put the-values of the-identifiers used in the-definition.

name::
* cpt.Ljs'function'call,
* cpt.Ljs'function'execution,
* cpt.Ljs'function'invocation,
* cpt.Ljs-f'call,
* cpt.Ljs-f'execution,
* cpt.Ljs-f'invocation,

Ljs-f'Input

description::
Function's-input is optional information (semantic-units) we give to a-function to do its work.

name::
* cpt.Ljs'function'input,
* cpt.Ljs-f'input,

Function's-parameter:
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.

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

Ljs-f'Output

description::
Function's-output is optional information (semantic-unit) we could-RECEIVE from a-function.
If a-function has no output, then the-output is-considered the-undefined-semantic-unit.

name::
* cpt.Ljs'function'output,
* cpt.Ljs-f'output,

return-sentence:
The last sentence in the-definition-of-a-function is the-return-sentence, the-sentence that denotes what the-function will return.
Code: return o;

name::
* cpt.Ljs'return-sentence,
* cpt.Ljs'return-statement,
* cpt.Ljs'sentence.return,

Ljs-f'name

description::
The-name of a-function it's a little tricky business.
In this definition: function f(){}, the-name is 'f': f.name //"f"
In this definition: var f = function(){}, there is no name: f.name //""
In this definition: var f1 = function f2(){}, the-name is 'f2': f1.name //"f2"; f2.name //error
In all other name-value-pairs we consider the-identifier as 'name'.
So when we need to create recursive-functions (= functions which call themselves), we use the first definition where the-name and the-reference to the-function are the-same.

Ljs-f'Scope (link)

name::
* cpt.Ljs-f'Scope,

Ljs-f'A-function-is-an-object

description::
This natural-language sentence is ambiguous.
First of all, the-verb 'is' has many meanings, eg 'has', 'is-specific-of', 'is-part-of' etc.
In javascript means that a-function is specific of the-object Object.prototype, then and a-function is an-object.
Thus, a-function can-have members, like an-object.
A-function has the-members of its generics-chain.
BUT a-function has and other characteristics that an-object can-not have.
We can-call a-function, but not an-object.
Then, the correct sentence is: A-function is a specific of Object.prototype.

Ljs-f'Function.prototype

description::
Function.prototype[1] is the-generic-object, of all functions.
In other words, its[1] members are-inherited by all functions.
Usually, Constructor.prototype is an-object.
But Function.prototype is a-function: typeof Function.prototype //"function"

name::
* cpt.Ljs'Function.prototype,
* cpt.Ljsf.Function.prototype,
* cpt.Ljs'Function.prototype-function,

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

generic-chain::
* Object.prototype (Function.prototype.__proto__ === Object.prototype //true),

member::
Code (Chrome.50):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "arguments", "bind", "call", "caller", "constructor", "length", "name", "toString"]

(Firefox.46):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "arguments", "bind", "call", "caller", "constructor", "isGenerator", "length", "name", "toSource", "toString"]

(Edge.20):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "arguments", "bind", "call", "caller", "constructor", "length", "name", "toString"]

(Safari.5-1-7):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "bind", "call", "constructor", "length", "name", "toString"]

specific::
* Function,
* Object,
* ...
* all builtin functions,
* all custom-functions,

Ljs-f'Function-function

description::
Function is the-constructor, of all functions:
> var f = function(){};
undefined
> f.constructor
function Function() { [native code] }

name::
* cpt.Ljs'Function-constructor,
* cpt.Ljs'Function-function,

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

generic-chain::
* Function.prototype, (Function.__proto__ === Function.prototype //true),
It is important to mention here that Function CONTAINS its generic-object, the-Function.prototype.
* Object.prototype, (Function.__proto__.__proto__ === Object.prototype //true)

member::
Code (Chrome.50):
> Object.getOwnPropertyNames(Function).sort()
[]

(Firefox.46):
> Object.getOwnPropertyNames(Function).sort()
[]

(Edge.20):
> Object.getOwnPropertyNames(Function).sort()
[]

(Safari.5-1-7):
> Object.getOwnPropertyNames(Function).sort()
[]

Ljs-f.SPECIFIC

name::
* cpt.Ljs'function.specific,

Specific.alphabetically::
* constructor-function,
* custom-function,
* customNo-function,
* method-function,
* methodNo-function,
* named-function,
* namedNo-function,
* object-returning-function,
* operator-function,
* self-executing-function,

Ljs-f.ARROW

description::
· arrow-functions is an ES6 feature.

example::
var fAdd = (nAIn, nBIn) => nAIn + nBIn;
//or
var fAdd = (nAIn, nBIn) => {
 return nAIn + nBIn;
}
//regular function
function fAdd(nAIn, nBIn) {
 return nAIn + nBIn;
}

name::
* cpt.arrow-function.javascript,
* cpt.fat-arrow-function.javascript,
* cpt.javascript-function.arrow,
* cpt.Ljs-f.arrow,

addressWpg::
* {2018-06-05} Cynthia-Lee, When (and why) you should use ES6 arrow functions — and when you shouldn’t, https://medium.freecodecamp.org/,

Ljs-f.ASYNC

description::
ES 2017 introduced Asynchronous functions.
Async functions are essentially a cleaner way to work with asynchronous code in JavaScript.
In order to understand exactly what these are, and how they work, we first need to understand Promises.
... Async functions return a Promise. If the function throws an error, the Promise will be rejected. If the function returns a value, the Promise will be resolved.
[https://codeburst.io/javascript-es-2017-learn-async-await-by-example-48acc58bad65]

name::
* cpt.async-function.javascript,
* cpt.Ljs'function.async,

addressWpg::
* {2017-11-07} Brandon-Morelli, JavaScript ES 2017: Learn Async/Await by Example, https://codeburst.io/,
* {2017-08-31} Diogo-Spínola, JavaScript — from callbacks to async/await, https://medium.freecodecamp.org/,

Ljs-f.CLASS

description::
JavaScript classes introduced in ECMAScript 2015 are syntactical sugar over JavaScript's existing prototype-based inheritance. The class syntax is not introducing a new object-oriented inheritance model to JavaScript. JavaScript classes provide a much simpler and clearer syntax to create objects and deal with inheritance.
Defining classes
Classes are in fact "special functions", and just as you can define function expressions and function declarations, the class syntax has two components: class expressions and class declarations.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes]

name::
* cpt.javascript'class,
* cpt.Ljs'class,
* cpt.Ljs'class,
* cpt.Ljs'class-function,
* cpt.Ljs-f.class,
===
I name a-class-function as: fNameCls.

addressWpg::
* http://www.2ality.com/2015/02/es6-classes-final.html,

Evaluation:
My-evaluation: on-inheritance, on-todo.

Ljs-f.CONSTRUCTOR

description::
Constructor is any function used to create objects using the-new keyword.
Code:
var oName = new fName();

name::
* cpt.constructor-function.javascript,
* cpt.javascript'constructor,
* cpt.Ljs'constructor,
* cpt.Ljs'constructor,
* cpt.Ljs'constructor-function,
* cpt.Ljs-f.constructor,
* cpt.Ljs'function.constructor,
===
Usually the-names of individual constructors begin with capital-letters.
===
I name a-constructor-function as: fNameCsr.

Constructor.prototype:
The-members of this special member of a-constructor, are-inherited by the-objects-created-by-a-constructor.
In other words, Constructor.prototype is the-generic-object of a-constructor's objects.

Ljs-f.METHOD

description::
Method is a-function member of an-object.

name::
* cpt.Ljs'function.method,
* cpt.javascript'method,
* cpt.Ljs'method,
* cpt.Ljs-f.method,
* cpt.Ljs'method,

Ljs-f.NAMED

description::
Named-function is a-function which has name.

// defined as:
function f(){};
// or
var f1 = function f2(){};

name::
* cpt.Ljs'named-function,
* cpt.Ljs'function.named,
* cpt.Ljs-f.named,

Ljs-f.NAMED.NO

description::
NamedNo-function is a-function which has NO name.

// defined as:
var f = function(){};

name::
* cpt.Ljs'anonymous-function,
* cpt.Ljs'namedNo-function,
* cpt.Ljs'function.namedNo,
* cpt.Ljs-f.namedNo,

Ljs-f.OBJECT-RETURNING

description::
Objects have no scope.
To overcome this, we create objects by creating functions[1], which have scope, that[1] return the-object we want.
Code:
function f() {
 var n = 1;
 function f1(){var n2 = n;}
 return {
   f1: f1;
   n: n;
 };
}

name::
* cpt.Ljs'factory-function,
* cpt.Ljs'function.object-returning,
* cpt.Ljs'object-factory-function,
* cpt.Ljs'object-returning-function,
* cpt.Ljs-f.factory,
* cpt.Ljs-f.object-factory,
* cpt.Ljs-f.object-returning,

addressWpg::
* https://www.sitepoint.com/factory-functions-javascript/,

Ljs-f.OPERATOR (Ljs-opr)

description::
Operators are special functions with code similar to natural-languages and names special-symbols and special syntax.
Operators[1] are built-in, and a-programer calls them[1].

name::
* cpt.javascript'operator-(Ljs-opr),
* cpt.javascript'operator,
* cpt.Ljs'operator,
* cpt.Ljs'opr-(Javascript-operator),
* cpt.operator-in-javascript-(Ljs-opr),

Operand-of--Ljs-opr

description::
Operands are the INPUT information of operators.

name::
* cpt.javascript'operand,
* cpt.Ljs'operand,

Ljs-opr.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,

Ljs-opr.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::
* cpt.Ljs'operator.Unary,
* cpt.javascript'unary-operator,
* cpt.Ljs'unary-operator,
* cpt.unary-operator.javascript,

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

Ljs-opr.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::
* cpt.Ljs'operator.Binary,
* cpt.javascript'binary-operator,
* cpt.Ljs'binary-operator,
* cpt.binary-operator.javascript,

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

Ljs-opr.TERNARY

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

name::
* cpt.Ljs'operator.Ternary,
* cpt.javascript'ternary-operator,
* cpt.Ljs'ternary-operator,
* cpt.ternary-operator.javascript,

specific::
* Conditional-operator,

Ljs-opr.CONDITIONAL

description::
The conditional operator is the only JavaScript operator that takes three operands.
The operator can have one of two values based on a condition.
The syntax is:
condition ? val1 : val2
If condition is true, the operator has the value of val1.
Otherwise it has the value of val2.
You can use the conditional operator anywhere you would use a standard operator.
For example,
var status = (age >= 18) ? 'adult' : 'minor';
This statement assigns the value "adult" to the variable status if age is eighteen or more.
Otherwise, it assigns the value "minor" to status.
[https://developer.mozilla.org/el/docs/Web/JavaScript/Guide/Expressions_and_Operators]

name::
* cpt.Ljs'operator.Conditional,
* cpt.javascript'conditional-operator,
* cpt.Ljs'conditional-operator,
* cpt.conditional-operator.javascript,

Ljs-opr.typeof

description::
typeof does not throw an error in case the identifier cannot be resolved, it merely returns the string 'undefined'.
... The first oddity is that typeof null returns object, which does not make any sense.
It is a dangerous pitfall.
[https://molily.de/robust-javascript/#how-to-prevent-failure]

name::
* cpt.Ljs'operator.typeof,
* cpt.javascript'typeof-operator,
* cpt.Ljs'typeof-operator,
* cpt.typeof-operator.javascript,

Ljs-f.SELF-EXECUTING

description::
Self-executing-function is a-function which defined and called at the same time.
Code:
(function() {
 //what to do
 //last, what to return
})();

name::
* cpt.Ljs'function.self-executing,
* cpt.Ljs'self-executing-function,
* cpt.Ljs-f.self-executing,
* cpt.Ljs'self-executing-function,

Immediately-invoked-function-expression (IIFE):
It is the-sentence in the-code that defines and calls the-function.

Ljs-Sut.MODULE (ljs-m)

description::
Module is a-semantic-unit which
- can-be PART OF other modules and
- can-has AS PART other modules.
Like 'the-prototype-inheritance' mechanism which manages the GENERIC-SPECIFIC relations of the-semantic-units of an-API, modules is the-mechanism needed to manage the WHOLE-PART relations of the-semantic-units.
Today only Ljn supports modules.

name::
* cpt.javascript'module--semantic-unit,
* cpt.Ljs'module--semantic-unit,
* cpt.Ljs'Sut.module,
* cpt.Ljs'module,
* cpt.Ljs-m,
* cpt.module--semantic-unit--of-javascript-(Ljs-m),

scope::
With modules, you group the variables and functions that make sense to go together.
This puts these functions and variables into a module scope.
The module scope can be used to share variables between the functions in the module.
But unlike function scopes, module scopes have a way of making their variables available to other modules as well. They can say explicitly which of the variables, classes, or functions in the module should be available.
[https://hacks.mozilla.org/2018/03/es-modules-a-cartoon-deep-dive/]

addressWpg::
* {2018-06-18} Addy-Osmani, Mathias-Bynens, Using JavaScript modules on the web, https://developers.google.com/web/fundamentals/,
* {time.2018-03-28} Lin-Clark, ES modules: A cartoon deep-dive: https://hacks.mozilla.org/2018/03/es-modules-a-cartoon-deep-dive/,
* {time.2017-05-02} ECMAScript modules in browsers: https://jakearchibald.com/2017/es-modules-in-browsers/,

generic-chain::
* semantic-unit,

specific::
* Nodejs-module,

Ljs-Sut.NULL (ljs-l)

description::
Null is a special semantic-unit that denotes no-information, similar to zero quantity.

name::
* cpt.javascript'null--semantic-unit,
* cpt.javascript'null--semantic-unit,
* cpt.Ljs'null--semantic-unit,
* cpt.Ljs'Sut.null,
* cpt.Ljs'null,
* cpt.Ljs'null,
* cpt.Ljs-l,
* cpt.null--semantic-unit--of-javascript-(Ljs-x),

generic-chain::
* objectNo,
* semantic-unit,
===
'null is not an object'.
In other words, null is NOT SPECIFIC of an-ljs-object, it does not inherit the-members of an-object.
===
> typeof null //"object"
is a-MISTAKE of the-language (like instanceof)!

Code:
null

Ljs-Sut.NUMBER (ljs-n)

description::
Number is a-semantic-unit that denotes numbers in archetype.

name::
* cpt.javascript'number--semantic-unit,
* cpt.javascript'number--semantic-unit,
* cpt.Ljs'number--semantic-unit,
* cpt.Ljs'Sut.number,
* cpt.Ljs'number,
* cpt.Ljs-n,
* cpt.Ljs-n-(number),
* cpt.Ljs'number,
* cpt.Number--semantic-unit--of-javascript-(Ljs-n),

generic-chain::
* Number.prototype, ((3).__proto__ === Number.prototype //true)
* Object.prototype, ((3).__proto__.__proto__ === Object.prototype //true)

Ljs-n'Number.prototype

description::
Number.prototype is the-generic-object, of all numbers.
In other words, its members are-inherited by all numbers.

name::
* cpt.Ljs-o.Number.prototype,
* cpt.Ljs'Number.prototype-object,

generic-chain::
* Object.prototype (Number.prototype.__proto__ === Object.prototype //true),

member::
(Node.6.3.0):
> Object.getOwnPropertyNames(Number.prototype).sort()
[ 'constructor', 'toExponential', 'toFixed', 'toLocaleString', 'toPrecision', 'toString', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(Number.prototype).sort()
["constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toString", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(Number.prototype).sort()
["constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toSource", "toString", "valueOf"]

(Edge.20):
> Object.getOwnPropertyNames(Number.prototype).sort()
[constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toString", "valueOf"]

(Safari.5-1-7):
> Object.getOwnPropertyNames(Number.prototype).sort()
["constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toString", "valueOf"]

Number.prototype.toLocaleString-function

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

name::
* cpt.javascript'Number.prototype.toLocaleString-function,
* cpt.Ljs'Number.prototype.toLocaleString-function,
* cpt.Number.prototype.toLocaleString-function.javascript,

Ljs-n.NaN

description::
The problem is, NaN is a dangerous beast.
NaN is a special value that means “not a number”, but in fact it is a number you can calculate with.
NaN is contagious.
All calculations involving NaN fail silently, yielding NaN: 5 + NaN makes NaN, Math.sqrt(NaN) produces NaN.
All comparisons with NaN yield false: 5 > NaN is false, 5 < NaN is also false. 5 === NaN is false, NaN === NaN is also false.
If a NaN slips into your logic, it is carried through the rest of the program until the user sees a “NaN” appearing in the interface.
It is hard to find the cause of a NaN since the place where it appears can be far from the place that caused it.
Typically, the cause of a NaN is an implicit type conversion.
My advice is to raise the alarm as soon as you see a NaN.
[https://molily.de/robust-javascript/#failing-fast]

name::
* cpt.javascript'NaN,
* cpt.Ljs'NaN,
* cpt.Ljs-n.NaN,

Ljs-Sut.OBJECT (Ljs-o)

description::
· object is a-collection of name-value-pairs, which inherits the-members of the-Object.prototype, in other words it is SPECIFIC of the-Object.prototype.
· objects are semantic-units that map concepts.
· the famous sentence 'everything is an object', is wrong because there are and non-objects.
· the correct sentence is: 'almost everything is an-Object.prototype'.

name::
* cpt.javascript'object--semantic-unit,
* cpt.Ljs'object--semantic-unit,
* cpt.Ljs'Sut.object,
* cpt.javascript-object-(Ljs-o),
* cpt.Ljs-o'(Javascript-object),
* cpt.Ljs'object,
* cpt.Object--semantic-unit.javascript,

Member-of--Ljs-o

description::
Members are-called the-name-value-pairs of an-object.

name::
* cpt.Ljs'member-of-an-object,
* cpt.Ljs'object'member,
* cpt.Ljs-o'member,
* cpt.Ljs-o'property,
===
* Some (spec) call the-members-of-an-object 'properties', and some (MDN) with 'properties' call the-non-methods-members-of-an-object.

Same-name:
The-members of an-object can-NOT-have the-same name.
> var o = {a:1, a:2, a:3, A:4};
< Object {a: 3, A: 4}

Creating:
a) with the-creation of the-object.
b) after object creation with the-code:
object.member = value;

Access:
To access a-member of an-object, Ljs uses the-code:
// dot notation
object.member
// array notation
object["member"]


Array-notation gives us the-option to access a-member with variables:
var o = {sMbr:'a-string', nMbr:2};
var sM1 = 's' + 'Mbr';
console.log(o[sM1]) //returns 'a-string'

specific::
* Custom: not a-unit native to language.
* CustomNo: a-unit native to language.
* Inherited: a-member of its generic-objects.
* InheritedNo,
* Method: a-member which is a-function.
* MethodNo: any other member. Some call them 'properties'.
* Internal: a-unit created inside current-algorithm.
* InternalNo: a-unit created in another algorithm and imported into current-algorithm.
* Public: a-member we have access from outside of the-object. ALL members of a-generic-object are public.
* PublicNo: A-function (a-specific-object) has publicNo members.

Scope-of--Ljs-o (link)

WHOLE-of--Ljs-o

Whole-chain::
=== (syntax--whole-part-tree)
* Ljs-phrase,
* Ljs-sentence,
* Ljs-library,
* Ljs-program,
=== (API--whole-part-tree)
* another semantic-unit,
...
* window,

GENERIC-of--Ljs-o

generic-chain::
The-generic-object of an-object is-called 'prototype'.
The-generic-object inherits its members TO its specifics.
[HmnSgm.2017-10-11]
===
JavaScript objects are dynamic "bags" of properties (referred to as own properties).
JavaScript objects have a link to a prototype object.
When trying to access a property of an object, the property will not only be sought on the object but on the prototype of the object, the prototype of the prototype, and so on until either a property with a matching name is found or the end of the prototype chain is reached.

[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain#Inheriting_properties]
===
* Object.prototype, (literal-objects ({}).__proto__ === Object.prototype //true)
or
* Constructor.prototype, (constructor-objects)
or
* objectX, (var o = Object.create(objectX))

name::
* cpt.generic-chain.javascript,
* cpt.Ljs'prototype-chain,
* cpt.prototype-chain.javascript,

Ljs-o.SPECIFIC

Specific.alphabetically::
* constructor-object,
* constructorNo-object,
* custom-object,
* customNo-object,
* first-class-object,
* first-class-no-object,
* literal-object,
* literalNo-object,
* most-generic-object,
* most-whole-object,

Ljs-o.CONSTRUCTOR

description::
Constructor-object is an-object created with a-constructor-function: var o = new Constructor();

name::
* cpt.Ljs'constructor-object,
* cpt.Ljs'object.constructor,
* cpt.Ljs'object-created-by-a-constructor,
* cpt.Ljs'constructor-object,
* cpt.Ljs-o.constructor,
===
I use to name individual constructor-objecs as: oConstructor which helps reading the-code.

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

member::
A-constructor-object[1] has as members the-members of its constructor that are-prefixed with this.
Also it[1] INHERITS the-members of the-Constructor.prototype-object.
It is A-MISTAKE to call the-object-of-a-constructor, INSTANCE of the-constructor.

Ljs-o.CONSTRUCTOR.NO

description::
ConstructorNo-object is an-object NOT-CREATED with a-constructor-function: var o = new Constructor();
There are 3 cases:
a) a-literal-object.
b) var o = Object.create(o2);
Here, o2 is a-generic of o.
c) object created as a return of a-function.

name::
* cpt.Ljs'constructorNo-object,
* cpt.Ljs'nonconstructor-object,
* cpt.Ljs'object.constructorNo,
* cpt.Ljs'object-not-created-by-a-constructor,
* cpt.Ljs-o.constructorNo,

Ljs-o.FIRST-CLASS

description::
First-class-object is an-object which can-have members.
[https://developer.mozilla.org/en-US/docs/Web/javascript/Reference/Functions]

name::
* cpt.Ljs'first-class-object,
* cpt.Ljs'firstclass-object,
* cpt.Ljs'object.first-class,
* cpt.Ljs'first-class-object,
* cpt.Ljs'firstclass-object,
* cpt.Ljs-o.first-class,

specific::
* array,
* function,
* regexp,
* number-non-literal, (var n = new Number(2))
* string-non-literal, (var s = new String('string'))

Ljs-o.FIRST-CLASS.NO

description::
First-class-no- object is an-object which can-NOT-have members.
[https://developer.mozilla.org/en-US/docs/Web/javascript/Reference/Functions]

name::
* cpt.Ljs'first-class-object.no,
* cpt.Ljs'first-class-object.no,
* cpt.Ljs'firstclass-object.no,
* cpt.Ljs'firstclass-object.no,
* cpt.Ljs'object.first-class.no,
* cpt.Ljs'object.first-class.no,
* cpt.Ljs-o.first-class.no,

specific::
* boolean,
* number-literal, (var n = 2)
* string-literal, (var s = 'string')

Ljs-o.LITERAL

description::
Literal-object is an-object created directly by the-programer.
Code:
var o = {
 a: [1, 's'],
 b: true,
 f: function(){},
 n: 2,
 o2: {n:1, s:'s'},
 r: /d/,
 s: 'string',
}

name::
* cpt.Ljs'literal-object,
* cpt.Ljs'object.literal,
* cpt.Ljs'literal-object,
* cpt.Ljs-o.literal,

generic-chain::
* Object.prototype,

Ljs-o.LITERAL.NO

description::
LiteralNo-object is an-object NOT created directly by the-programer.

name::
* cpt.Ljs'literalNo-object,
* cpt.Ljs'non-literal-object,
* cpt.Ljs'object.literalNo,
* cpt.Ljs'literalNo-object,
* cpt.Ljs-o.literalNo,

specific::
* constructor-object,
* var o = Object.create(o2);
* object created as a return of a-function.

Ljs-Sut.REGEXP (ljs-r)

description::
RegExp (regular-expression) denotes parts of texts.
They are the-query-language for texts in archetype.
Code-example:
var r = /d/;

name::
* cpt.javascript'regexp--semantic-unit,
* cpt.Ljs'regexp--semantic-unit,
* cpt.Ljs'Sut.regexp,
* cpt.Ljs-r,
* cpt.Ljs-r-(regular-expression),
* cpt.Ljs'regexp,
* cpt.regexp--semantic-unit--of-javascript-(Ljs-r),

generic-chain::
* RegExp.prototype, (/r/.__proto__ === RegExp.prototype //true)
* Object.prototype, (/r/.__proto__.__proto__ === Object.prototype //true)

Ljs-n'RegExp.prototype

description::
RegExp.prototype is the-generic-object, of all regexp.
In other words, its members are-inherited by all regexp.

name::
* cpt.Ljs-o.RegExp.prototype,
* cpt.Ljs'RegExp.prototype-object,

generic-chain::
* Object.prototype (RegExp.prototype.__proto__ === Object.prototype //true),

member::
(Chrome.50):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "flags", "global", "ignoreCase", "multiline", "source", "sticky", "test", "toString", "unicode"]

(Firefox.46):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "flags", "global", "ignoreCase", "lastIndex", "multiline", "source", "sticky", "test", "toSource", "toString", "unicode"]

(Edge.20):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "global", "ignoreCase", "lastIndex", "multiline", "options", "source", "test", "toString", "unicode"]

(Safari.5-1-7):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "global", "ignoreCase", "lastIndex", "multiline", "source", "test", "toString"]

Ljs-Sut.STRING (Ljs-s)

description::
· strings represent any text in archetype.
· strings have meaning for humans, but NOT for the-machines.
Code-example:
var s = 'string';

name::
* cpt.javascript'string,
* cpt.javascript'string--semantic-unit,
* cpt.Ljs'string,
* cpt.Ljs'string--semantic-unit,
* cpt.Ljs-s,
* cpt.Ljs-s-(string-of-javascript),
* cpt.Ljs'Sut.string,
* cpt.string--semantic-unit--of-javascript-(Ljs-s),

generic-chain::
* String.prototype, (''.__proto__ === String.prototype //true)
* Object.prototype, (''.__proto__.__proto__ === Object.prototype //true)

addressWpg::
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/
* https://mathiasbynens.be/notes/javascript-escapes,

example::
"a string"
'another string'
'\uD834\uDF06' //𝌆
'\u{1D306}' //𝌆

String.prototype-object--of--Ljs-s

description::
String.prototype is the-generic-object, of all strings.
In other words, its members are-inherited by all strings.

name::
* cpt.Ljs-o.String.prototype,
* cpt.javascript'String.prototype,
* cpt.Ljs'String.prototype,
* cpt.Ljs'String.prototype-object,

addressWpg::
* members with examples: https://gist.github.com/rauschma/,

generic-chain::
* Object.prototype (String.prototype.__proto__ === Object.prototype //true),

member::
(Node.6.3.0):
> Object.getOwnPropertyNames(String.prototype).sort()
[ 'anchor', 'big', 'blink', 'bold', 'charAt', 'charCodeAt', 'codePointAt', 'concat', 'constructor', 'endsWith', 'fixed', 'fontcolor', 'fontsize', 'includes', 'indexOf', 'italics', 'lastIndexOf', 'length', 'link', 'localeCompare', 'match', 'normalize', 'repeat', 'replace', 'search', 'slice', 'small', 'split', 'startsWith', 'strike', 'sub', 'substr', 'substring', 'sup', 'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimLeft', 'trimRight', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "codePointAt", "concat", "constructor", "endsWith", "fixed", "fontcolor", "fontsize", "includes", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "normalize", "repeat", "replace", "search", "slice", "small", "split", "startsWith", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "codePointAt", "concat", "constructor", "contains", "endsWith", "fixed", "fontcolor", "fontsize", "includes", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "normalize", "repeat", "replace", "search", "slice", "small", "split", "startsWith", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toSource", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

(Edge.20):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "codePointAt", "concat", "constructor", "endsWith", "fixed", "fontcolor", "fontsize", "includes", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "normalize", "repeat", "replace", "search", "slice", "small", "split", "startsWith", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

(Safari.5-1-7):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "concat", "constructor", "fixed", "fontcolor", "fontsize", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "replace", "search", "slice", "small", "split", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

String.prototype.codePointAt-function

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

name::
* cpt.javascript'codePointAt-function,
* cpt.Ljs'codePointAt-function,
* cpt.String.prototype.codePointAt-function,
* cpt.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::
* cpt.javascript'match-function,
* cpt.Ljs'match-function,
* cpt.String.prototype.match-function,
* cpt.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::
* cpt.javascript'replace-function,
* cpt.Ljs'replace-function,
* cpt.String.prototype.replace-function,
* cpt.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

String.prototype.substring-function

name::
* cpt.javascript'substring-function,
* cpt.Ljs'substring-function,
* cpt.String.prototype.substring-function,
* cpt.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

String-function--of--Ljs-s

description::
The-String-function contains the-String.prototype-object is the-generic-object, of all strings.

name::
* cpt.Ljs'String-function,
* cpt.String-function.javascript,

Member::
(Chrome.61)> Object.getOwnPropertyNames(String)
(6) ["length", "name", "prototype", "fromCharCode", "fromCodePoint", "raw"]

Ljs-Sut.UNDEFINED (ljs-u)

description::
Undefined is a-semantic-unit that denotes a-name-value-pair without value assigned (initialized).
Also it is-used to denote that a-function has no output.
Code: undefined

name::
* cpt.javascript'undefined--semantic-unit,
* cpt.Ljs'undefined--semantic-unit,
* cpt.Ljs'Sut.undefined,
* cpt.Ljs-u,
* cpt.Ljs'undefined,
* cpt.undefined--semantic-unit--of-javascript-(Ljs-u),

generic-chain::
* objectNo,
* semantic-unit,

src-doc-sut.API

description::
API is a-set of semantic-units.
An-API, like any conceptual-information, is-structured at the SAME time, into 3 different tree-structures:
1) A-whole-part-tree with root-node the-most-whole-object and
2) A-generic-specific-tree with root-node the-most-generic-object (Object.prototype).
3) A-directory-tree structure.
The-discovery (not invention) that an-API has and a-whole-part and a-generic-specific tree-structure, is mine which I first discovered to has any human-conceptual-information.

name::
* cpt.API.Ljs,
* cpt.javascript'API,
* cpt.Ljs'API,
* cpt.Ljs'Application-Programming-Interface,

Ljs-API'Most-whole-object (global)

description::
The whole-part relations of semantic-units form a whole-part-tree structure.
The-ROOT-node of this structure is the most-whole-object and contains all others.
It is called the-global-object.
With the same name are-called and its children (not its descendants).
In Ljb, this is the-window-object.
In Ljn, this is the-global-object.

name::
* cpt.javascript'global-object,
* cpt.javascript'most-whole-object,
* cpt.Ljs'global-object,
* cpt.Ljs'most-whole-object,
* cpt.Ljs'Mwo,
* cpt.most-whole-object.Ljs,

Whole-chain::
* none,

generic-chain::
...
* Object.prototype,
LOOK-THAT: the-most-whole-object is specific of the-most-generic-object.

Ljsmwo'Member

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

name::
* cpt.Ljs'global-member,
* cpt.Ljs'globals,
* cpt.Ljs'member-of-most-whole-object,

specific::
* ljb-global-member,
* Ljn-global-member,

Ljs-API'Most-generic-object (Object.prototype)

description::
All Ljs-objects inherit the-members of this object.
Object.prototype is the-ROOT node of the-API-generic-specific-tree of ALL javascript dialects.

name::
* cpt.javascript'Object.prototype,
* cpt.javascript'most-generic-object,
* cpt.Ljs'Object.prototype,
* cpt.Ljs'mgo-(most-generic-object),
* cpt.Ljs'most-generic-object,
* cpt.most-generic-object.Ljs,
* cpt.Object.prototype.javascript,

Whole-chain::
* Object,
* most-whole-object,
LOOK-THAT: the-most-generic-object is part of the-Object-function, which is part of the-most-whole-object.

generic-chain::
* none,

member::
(ljn.6-3-1)
> Object.getOwnPropertyNames(Object.prototype).sort()
[ '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__', 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toSource", "toString", "unwatch", "valueOf", "watch"]

(Edge.20):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"]

(Safari.5-1-7):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"]

specific::
* Ljb-Object.prototype,
* Ljn-Object.prototype,

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::
* cpt.Ljs'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,

Ljs'Object.create-function

description::
The Object.create() method creates a new object with the specified prototype object and properties.
Syntax
Object.create(proto[, propertiesObject])
Parameters
proto
The object which should be the prototype of the newly-created object.
propertiesObject
Optional. If specified and not undefined, an object whose enumerable own properties (that is, those properties defined upon itself and not enumerable properties along its prototype chain) specify property descriptors to be added to the newly-created object, with the corresponding property names. These properties correspond to the second argument of Object.defineProperties().
Return value
A new object with the specified prototype object and properties.
Exceptions
A TypeError exception if the proto parameter isn't null or an object.

[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create]

name::
* cpt.Ljs'Object.create-function,

Ljs'Object.getOwnPropertyNames-function

description::
The Object.getOwnPropertyNames() method returns an array of all properties (enumerable or not) found directly upon a given object.
Syntax
Object.getOwnPropertyNames(obj)
Parameters
obj
The object whose enumerable and non-enumerable own properties are to be returned.
Return value
An array of strings that correspond to the properties found directly upon the given object.

[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames]

name::
* cpt.Ljs'Object.getOwnPropertyNames,
* cpt.Ljs'Object.getOwnPropertyNames-function,
* cpt.Ljs'Object.getOwnPropertyNames(),

Code:
> Object.getOwnPropertyNames(obj).sort() // to sort the-members.
> Object.getOwnPropertyNames(obj).join(', ') // to display ALL the-members.
> Object.getOwnPropertyNames(obj).filter(function(sM){return sM.match(/^[a-e]/)}) // to display the-members that begin with a-to-e.

Ljs-API'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::
* cpt.javascript'whole-part-tree-API,
* cpt.Ljs'API'whole-part-tree,
* cpt.Ljs'API-whole-part-tree,
* cpt.Ljs'whole-part-tree-of-api,
* cpt.Ljs'Wpt-API(javascript-whole-part-tree-API),

specific::
* Ljb-native-whole-part-tree,
* Ljn-native-whole-part-tree,

Ljs-API'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::
* cpt.javascript'generic-specific-tree-of-API,
* cpt.Ljs'API'generic-specific-tree,
* cpt.Ljs'generic-specific-tree-of-API,

specific::
* Ljb-native-generic-specific-tree,
* Ljn-native-generic-specific-tree,

Ljs-API.SPECIFIC

specific::
* ljb-API,
* ljn-API,
===
* native-API,
* nativeNo-API,
===
* vanilla-API,
* vanillaNo-API,
===
* library-API,
* program-API,

Ljs-API.NATIVE

Descripton:
Native-API is the-API with only and all the-native-semantic-units.
It has
- a-whole-part-tree-structure
- a-generic-specific-tree-structure and
- a-directory-tree-structure.

name::
* cpt.javascript'API.native,
* cpt.Ljs'API.native,
* cpt.Ljs'API.native,
* cpt.Ljs'native-API,
* cpt.Ljs'builtin-API,

Generic::
* Ljs-API,

specific::
* Ljb-native-API,
* Ljn-native-API,

Ljs'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::
* cpt.Error-function.javascript,
* cpt.javascript'Error-function,
* cpt.Ljs'Error-function,

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::
// ljn.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,

Ljs'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::
* cpt.JSON-object.javascript,
* cpt.Ljs-JSON-object,
* cpt.Ljs-o.JSON,

Whole-chain::
* Ljs-most-whole-object (global),

LjsJSON'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"

Ljs'JSON.parse-function

description::
The-JSON.parse()-function has as INPUT a-string that represents a-JSON-language-semantic-unit and OUTPUT the-javascript-semantic-unit that corresponds to that of JSON-language.

Code:
> var a = JSON.parse('[1,2]') //undefined
> a //[1, 2]
> var n = JSON.parse('2') //undefined
> n //2
> var o = JSON.parse('{"a":1,"b":2}') //undefined
> o //Object {a: 1, b: 2}

Ljs'JSON.stringify-function

description::
The-JSON.stringify()-function has as INPUT a-javascript-semantic-unit and OUTPUT a-string that corresponds to similar JSON-language-semantic-unit.

Code:
> JSON.stringify({a:1, b:2}) //"{"a":1,"b":2}"

Ljs'Math-object

name::
* cpt.Ljs'Math-object,
* cpt.Ljs-o.Math,
* cpt.Math-object.javascript,

Whole-chain::
* Ljs-most-whole-object (global),

LjsMath'Member::
(ljn.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' ]

Ljs'Promise-function

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::
* cpt.Ljs'Promise-function,
* cpt.Promise-function.javascript,

Member::
// ljn.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' ]

Resource:
* https://promisesaplus.com/,
===
{2017-10-31} Brandon-Morelli, JavaScript: Learn Promises, https://codeburst.io/,

Ljs'Set-function

description::
· the-Set-function create objects that contain not indexed data, only once.
· it is the-math-set-concept, in javascript.
[hmnSgm.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::
* cpt.Ljs'Api'Set-function,
* cpt.Ljs'Set-function,
* cpt.set.javascript,

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/,

Ljs'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::
* cpt.javascript'console-object,
* cpt.Ljs'console-object,
* cpt.Ljs'API'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"

Ljs'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::
* cpt.decodeURI-function.javascript,
* cpt.Ljs'decodeURI-function,

code.Ljs::
> 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:

Ljs-API.NATIVE.NO

Descripton:
NativeNo-API is an-API with custom-semantic-units, vanilla or not.

name::
* cpt.Ljs'API.nativeNo,
* cpt.Ljs'builtinNo-API,
* cpt.Ljs'nativeNo-API,

Ljs-API.VANILLA

Descripton:
Vanilla-API is an-API with only native-semantic-units and custom-semantic-units created in one algorithm (no external libraries).

name::
* cpt.Ljs'API.vanilla,
* cpt.Ljs'independent-API,
* cpt.Ljs'own-API,
* cpt.Ljs'plain-API,
* cpt.Ljs'vanilla-API,

Ljs-API.VANILLA.NO

Descripton:
VanillaNo-API is an-API which uses external libraries (has dependencies).

name::
* cpt.Ljs'API.vanillaNo,
* cpt.Ljs'dependent-API,
* cpt.Ljs'ownNo-API,
* cpt.Ljs'vanillaNo-API,

Ljs-API.Event

Descripton:
Events are DOINGS that trigger|call functions (listeners).

name::
* cpt.Ljs'API.Event,
* cpt.Ljs'event-API,

SPECIFIC:
* Ljb-event,
* Ljn-event,

src-doc'PHRASE

description::
Phrases[1] are whole-constructs of semantic-unit NAMES to denote relations of their archetypes that[1] cannot exist autonomously inside the-algorithm.

name::
* cpt.javascript'phrase,
* cpt.Ljs'phrase,
* cpt.Ljs'semantic-unit-structure,
* cpt.Ljs'Sus,

Whole-chain::
* Ljs-sentence,

Part::
* Ljs-semantic-unit,

Ljsphrase'Code

description::
Code-phrase is a-phrase written in code-format.
Examples:
o.member
a[3]
2 + 3
if (b)

name::
* cpt.Ljs'phrase.code,
* cpt.Ljs'code-phrase,

src-doc'SENTENCE

description::
Sentences are whole-constructs of semantic-units, Ljs-phrases and even other sentences that exists autonomously inside the-algorithm.
The-algorithm is a-whole-part-tree structure of sentences.

name::
* cpt.javascript'sentence,
* cpt.Ljs'sentence,
* cpt.javascript'statement,
* cpt.Ljs'statement,
* cpt.Ljs'sentence,
* cpt.Ljs'statement,
* cpt.sentence.javascript,
* cpt.statement.javascript,

Whole-chain::
* Ljs-program,

Part::
* Ljs-ljs-phrase,
* Ljs-semantic-unit,

Ljs-sentence.SPECIFIC

SPECIFIC.alphabetically:
* assignment-sentence,
* block-sentence,
* break-sentence,
* creation-sentence,
* conditional-sentence,
* continue-sentence,
* control-sentence,
* definition-sentence,
* delete-sentence,
* do-while-sentence,
* for-sentence,
* generic-sentence,
* genericNo-sentence,
* if-sentence,
* Immediately-invoked-function-expression,
* instance-sentence,
* instanceNo-sentence,
* label-sentence,
* loop-sentence,
* return-sentence,
* simple-sentence,
* simpleNo-sentence,
* switch-sentence,
* throw-sentence,
* while-sentence,

SPECIFIC_DIVISION.instance:
* instance-sentence (genericNo): has no specifics,
* instanceNo-sentence (generic),

SPECIFIC_DIVISION.simple:
* simple-sentence: denotes one relation or doing,
* simpleNo-sentence,

Ljs-sentence.ASSIGNMENT

description::
Assignment-sentence is a-sentence that puts|assigns a-value in a-name-value-pair.
Code:
n = 3;
s = "text";

name::
* cpt.javascript'assignment-sentence,
* cpt.Ljs'assignment-sentence,
* cpt.Ljs'assignment-sentence,
* cpt.Ljs'assignment-statement,
* cpt.Ljs'assignment-statement,

Ljs-sentence.BLOCK

description::
Block-sentence is a-sentence that contains an-order-set of other sentences.
Code:
{
 sentence1;
 sentence2;
 ...
}

name::
* cpt.javascript'block-sentence,
* cpt.Ljs'block-sentence,
* cpt.Ljs'block-sentence,
* cpt.Ljs'block-statement,
* cpt.Ljs'block-statement,

Ljs-sentence.DEFINITION

description::
Definitions are sentences that create instances of semantic-units.
In contrast to natural-languages, machines throw errors if a-sentence uses an undefined semantic-unit!!!

name::
* cpt.declaration.javascript,
* cpt.definition-sentence.javascript,
* cpt.definition-statement.javascript,
* cpt.javascript'definition-sentence,
* cpt.Ljs'definition-sentence,
* cpt.Ljs'definition-statement,
* cpt.Ljs'declaration,
* cpt.Ljs'def,
* cpt.Ljs'definition-sentence,
* cpt.Ljs'definition-statement,

specific::
* Function-definition,
* Name-value-pair--definition,

Ljs-sentence.definition.FUNCTION

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

name::
* cpt.Ljs'definition.function,
* cpt.Ljs'function'declaration,
* cpt.Ljs'function'definition-sentence,
* cpt.Ljs'definition.function,

Ljs-sentence.definition.NAME-VALUE-PAIR

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

name::
* cpt.Ljs'definition.Variable,
* cpt.Ljs'name-value-pair-definition,
* cpt.Ljs'variable-declaration,
* cpt.Ljs'variable-definition-sentence,
* cpt.Ljs'variable-statement,

generic-chain::
* Definition-sentence,

Ljs-def.SPECIFIC

specific::
* const-definition,
* let-definition,
* var-definition,

Ljs-def.const

description::
The const declaration creates a read-only reference to a value.
It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned.
[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/const]

name::
* cpt.javascript'const-definition,
* cpt.Ljs'const-definition,

Ljs-def.let

description::
The let statement declares a block scope local variable, optionally initializing it to a value. [https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/let]

name::
* cpt.javascript'let-definition,
* cpt.Ljs'let-definition,

Ljs-def.var

description::
The scope of a variable declared with var is its current execution context, which is either the enclosing function or, for variables declared outside any function, global. [https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/var]

name::
* cpt.javascript'var-definition,
* cpt.Ljs'var-definition,

Ljs-sentence.THROW

description::
The throw statement allows to throw an exception programmatically.
It expects an arbitrary value after the throw keyword, but Error objects and their subtypes are most useful.
[https://molily.de/robust-javascript/#programmatic-exceptions]

name::
* cpt.javascript'throw-sentence,
* cpt.Ljs'throw-sentence,
* cpt.Ljs'sentence.Throw,

src-doc'SECTION

description::
Ljs-section is a-whole-construct of Ljs-sentences.

name::
* cpt.javascript'section,
* cpt.Ljs'section,
* cpt.Ljs'section,

src-doc'ROOT-TREE

description::
Algo-root-tree is the OUTERMOST TREE of an-algorithm, in a-webpage.

name::
* cpt.Ljs'algo'root-tree,

Part::
* the-root-node,
* the-children of the-root-node,

src-doc.SPECIFIC

description::
With the-language programers create many algorithms.
The-quantity depends on the-archetypes known, and the-semantic-units of the-language.

name::
* cpt.Ljs'algo.specific,

specific::
* Ljb-algorithm,
* Ljn-algorithm,
===
* Animation,
* Browser-managing,
* Codomain,
* Event-managing,
* HML-managing,
* Library,
* Math-managing,
* Number-managing,
* Package-managing,
* Program,
* Time-managing,

src-doc.ANIMATION

name::
* cpt.Animation-javascript-algorithm,
* cpt.Ljs'algo.animation,

specific::
* http://animejs.com/,
* fractals: http://slicker.me/fractals/animate.htm,

src-doc.ARRAY-MANAGING

description::
An-algorithm is an-INSTANCE of communication.
The-set of all algorithms is the-codomain of the-language.

name::
* cpt.Array-managing.javascript,
* cpt.Ljs'array-managing,
* cpt.Ljs'algo.array-managing,

specific::
* Array-of-array-primitives.remove-duplicates,
* Array-of-array.sort,

src-doc.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::
* cpt.Array-of-array.includes.javascript,
* cpt.Ljs'array-of-array.includes,
* cpt.Ljs'algo.array-of-array.includes,

src-doc.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::
* cpt.Array-of-array-primitives.remove-duplicates.javascript,
* cpt.Ljs'array-of-array-primitives.remove-duplicates,
* cpt.Ljs'algo.array-of-array-primitives.remove-duplicates,

src-doc.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;
}
===
//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::
* cpt.Array-of-array.sort.javascript,
* cpt.Ljs'array-of-array.javascript,
* cpt.Ljs'algo.array-of-array.javascript,

src-doc.CHARACTER

description::
· character-management algos.

name::
* cpt.character-algo.javascript,
* cpt.javascript'character-algo,
* cpt.Ljs'algo.character,

example::
//surrogates of a-char above U+FFFF
"𝌆".charCodeAt(0).toString(16); //"d834"
"𝌆".charCodeAt(1).toString(16); //"df06"
'\ud834\udf06}' //"𝌆"
"𝌆".codePointAt(0) //119558
(119558).toString(16) //"1d306"
'\u{1d306}' //"𝌆"

src-doc.CHARTING

name::
* cpt.Ljs'algo.charting,
* cpt.Ljs'charting,

specific::
* Taucharts: https://www.taucharts.com/,

src-doc.CODOMAIN

description::
An-algorithm is an-INSTANCE of communication.
The-set of all algorithms is the-codomain of the-language.

name::
* cpt.Ljs'codomain,
* cpt.Ljs'domainOut,

src-doc.DATE-MANAGING

description::
Date related algorithms.

name::
* cpt.Ljs'date-managing,
* cpt.Ljs'algo.date-managing,

addressWpg::
* https://javascript.info/date,

SPECIFIC::
* Format-date-to-YYY-MM-DD,

src-doc.date.YYYY-MM-DD

code.Ljs:::
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::
* cpt.Ljs'date.YYYY-MM-DD,
* cpt.Ljs'algo.date.YYYY-MM-DD,

src-doc.DIALOG

name::
* cpt.javascript'dialog,
* cpt.Ljs'dialog,
* cpt.Ljs'algo.dialog,

specific::
* rmodal.js: 1.2 KB modal dialog box, with no dependencies,

src-doc.MATH-MANAGING

description::
Math, number managing related algorithms.

name::
* cpt.javascript'math-managing,
* cpt.Ljs'math-managing,
* cpt.Ljs'algo.math-managing,
* cpt.math-managing.Ljs,
* cpt.number-managing.Ljs,

specific::
* A 218b spreadsheet app in HTML/JS: http://xem.github.io/sheet/,

src-doc.HEX-TO-INT

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

name::
* cpt.hex-to-int.javascript,
* cpt.hexadecimal-to-decimal.javascript,
* cpt.javascript'hexadecimal-to-decimal,
* cpt.javascript'hex-to-int,
* cpt.Ljs'hexadecimal-to-decimal,
* cpt.Ljs'hex-to-int,

src-doc.INT-TO-HEX

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

name::
* cpt.decimal-to-hexadecimal.javascript,
* cpt.int-to-hex.javascript,
* cpt.javascript'decimal-to-hexadecimal,
* cpt.javascript'int-to-hex,
* cpt.Ljs'decimal-to-hexadecimal,
* cpt.Ljs'int-to-hex,

src-doc.OBJECT-MANAGING

description::
Doings with objects.

name::
* cpt.Ljs'object-managing,
* cpt.Ljs'algo.object-managing,

SPECIFIC::
* Find-key-by-value,
* member-counting,
* member-deleting,
* member-existance,

src-doc.object.EQUALITY

code.Ljs:::
[1,3] === [1,3] //false
a = [1,3]
b = [1,3]
a === b //false
c = a
a === c //true
a == c //true

name::
* cpt.Ljs'object-equality,
* cpt.Ljs'algo.object-equality,

src-doc.object.FIND-KEY-BY-VALUE

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

name::
* cpt.Ljs'object-find-key-by-value,
* cpt.Ljs'algo.object-find-key-by-value,

src-doc.object.MEMBER-COUNTING

code.Ljs:::
Object.keys(o).length

name::
* cpt.Ljs'object-member-counting,
* cpt.Ljs'algo.object-member-counting,

src-doc.object.MEMBER-DELETING

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

name::
* cpt.Ljs'object-key-deleting,
* cpt.Ljs'object-member-deleting,
* cpt.Ljs'algo.object-member-deleting,

src-doc.object.MEMBER-EXISTANCE

code.Ljs:::
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::
* cpt.Ljs'object-key-existance,
* cpt.Ljs'object-member-existance,
* cpt.Ljs'algo.object-member-existance,

src-doc.object.MEMBER-SORTING

code.Ljs:::
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::
* cpt.Ljs'object-member-sorting,
* cpt.Ljs'algo.object-member-sorting,

src-doc.LIBRARY

description::
Algo-library is an-algorithm which can-not-RUN autonomously, but inside another algo.
In other words, a-library HAS-NO an-executing-entry-point, like a-program.
A-library is a-container of NEW semantic-units and so has an-API.

name::
* cpt.Ljs'algo.library,
* cpt.javascript'library,
* cpt.Ljs'library,
* cpt.Ljs'framework,
* cpt.Ljs'plugin,
* cpt.Ljs'lbr,
* cpt.Ljs'library,

Whole-chain::
* Ljs-program,

Part::
* Ljs-sentence,

installing Ljs-library

description::
In Ljb you use the-hml-element script.
In Ljn with require() because a-library is a-module.

name::
* cpt.Ljs'lbr'adding,
* cpt.Ljs'lbr'installing,

Ljs-library.SPECIFIC

specific::
* Ljb-library,
* Ljn-library,
===
* vanilla-library,
* vanillaNo-library,

Ljs-library.VANILLA

description::
Vanilla-library is a-library that uses ONLY native-API.

name::
* cpt.Ljs'vanilla-library,
* cpt.Ljs'library.vanilla,
* cpt.Vanilla-library,

Ljs-library.CRYPTO

name::
* cpt.javascript-crypto-library,
* cpt.Ljs'library.crypto,

specific::
* Signal-protocol: https://github.com/signalapp/libsignal-protocol-javascript,

src-doc.PROGRAM

description::
Ljs-program is an-algorithm which can-RUN autonomously, written in code-format.
In other words, a-program HAS an-executing-entry-point.
A-program is a-container of NEW semantic-units and so has an-API.

name::
* cpt.Ljs'algo--program,
* cpt.Ljs'algo.program,
* cpt.Ljs'algo--program,
* cpt.javascript'program,
* cpt.Ljs'program,
* cpt.Ljs'program,

Part::
* Ljs-library,
* Ljs-sentence,

Ljspgm'Execution

description::
Ljs-program-execution is the-process of commanding it to work.
Ljb and Ljn programs are-executed very differently.
An-ljb-program is just opened on the-browser.
An-ljn-program is executing on command-line: node file-of-pgm

name::
* cpt.javascript'program-execution,
* cpt.Ljs'program-execution,
* cpt.Ljs'program'execution,
* cpt.Ljs'pgm'call,
* cpt.Ljs'pgm'execution,
* cpt.Ljs'pgm'invocation,
* cpt.Ljs'pgm'open,
* cpt.Ljs'pgm'run,

Ljspgm.SPECIFIC

specific::
* Ljb-program,
* Ljn-program,

src-doc.PACKAGE

description::
Ljs-package is a-library or a-program PLUS metadata describing the-code.

name::
* cpt.javascript'package,
* cpt.Ljs'package,
* cpt.Ljs'package,
* cpt.Ljs'pkg,

Package-dependency:
Package-dependency is any other external package IMPORTED into current package.

Package-manager:
(linkL)

specific::
* ljb-package,
* ljn-ljspackage,
===
* bower-package,
* npm-package,

binary-document of Ljs

description::
· the-source-code is-understood by abstract-machines.
· real-machines directly understand only binary-information.
· therefore, the-source-code is-translated (with programs) in a-binary-format in order to be-executed.
· javascript is a-scripting-language.
· this means that the-source-document is translated to binary-document and executing without any involvement of the-programer.

name::
* cpt.javascript'binary-algorithm,
* cpt.javascript'binary-doc,
* cpt.Ljs'binary-doc,
* cpt.Ljs'binary-doc,
* cpt.Ljs'bdoc,

evaluation of Ljs

name::
* cpt.javascript'evaluation,
* cpt.Ljs'evaluation,
* cpt.Ljs'evaluation,

Ljs'pro

Ljs'simplicity

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

Ljs'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::
* cpt.Inheritance.Ljs,
* cpt.Ljs'inheritance,

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

Ljs'con

Ljs'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.

Ljs'instanceof

description::
'Instance' is a-specific-concept with no more specifics.
'My-car' is an-instance of 'car'.
Ljs-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.
Brendan-Eich-tweet

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

name::
* cpt.Ljs'operator.instanceof,
* cpt.javascript'instanceof,
* cpt.Ljs'instanceof,
* cpt.instanceof.javascript,

Ljs'object-scope

description::
Today, ljs, 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::
* cpt.Ljs-o'Scope,
* cpt.Ljs-o'scope,

Ljs'todo

In my opinion Ljs needs:
1) Valuenames.
2) Object-scope.
3) No constructors.
Objects could-be-created by 1) functions like Object.create(), 2) functions returning objects (factories), and 3) literal-objects.
The-generic-chain to be: object > objectSpc > objectSpc > ...
And NOT: Object.prototype > Constructor.prototype > Constructor.prototype ...

human of Ljs

description::
Any human related to the-language.

name::
* cpt.javascript'human,
* cpt.Ljs'human,
* cpt.Ljs'human,
* cpt.Ljs'hmn,

human..Creator

description::
Creator is any human who contributed in the-creation of the-language.

name::
* cpt.javascript'creator,
* cpt.Ljs'creator,
* cpt.Ljs'creator,

specific::
* Designer: the-human who created the-spec of the-language,
* Implementor: the-human who created the-code to binary-code translator,

human..Programer

description::
Programer is a-human who creates programs.

name::
* cpt.javascript'programer,
* cpt.Ljs'programer,
* cpt.Ljs'programer,
* cpt.Ljs'pmr,

human..User

description::
User is a-human who uses|runs a-program.

name::
* cpt.javascript'user,
* cpt.Ljs'user,
* cpt.Ljs'user,
* cpt.Ljs'usr,

language-that-complile-to-javascript of Ljs

description::
Jeremy-Ashkenas, creator of CoffeeScript, maintains a big list with languages that compile to javascript at:
https://github.com/jashkenas/coffeescript/wiki/List-of-languages-that-compile-to-JS.

learning of Ljs

description::
My goal to write this page, is to help the-learning of the-language from a-linguistic perspective.

My second innovation is the-representation of the-subject.
I am-not-writing down a-bla-bla-text describing the-subject, repeating characteristics here and there.
I am-writing STRUCTURED-CONCEPTS|ModelConceptStructureds in ONE format.
You can-read the-concept of javascript sequentially OR you can-search for a-characteristic and from there to reach any related concept.

name::
* cpt.javascript'learning,
* cpt.Ljs'learning,
* cpt.javascript'resource,
* cpt.Ljs'resource,

addressWpg::
* {2017-11-21} How JavaScript works: A comparison with WebAssembly + why in certain cases it’s better to use it over JavaScript: https://blog.sessionstack.com/,
* {2017-08-10} How JavaScript works: an overview of the engine, the runtime, and the call stack: https://blog.sessionstack.com/,
* https://developer.mozilla.org/en-US/Learn/JavaScript,
* https://www.codementor.io/learn-javascript-online,
=== Book:
* Robust Client-Side JavaScript: A Developer’s Guide: https://molily.de/robust-javascript/,

specific::
* learning-browser-javascript,
* learning-Node-javascript,

specification-of-Ljs (Ljs-spec)

description::
· specification is a-text-document that describes|defines a-language.
[HmnSgm.2018-01-06]
===
There is no single technical specification that defines JavaScript, but a whole bunch of specifications.
[https://molily.de/robust-javascript/#javascript-standards]

name::
* cpt.javascript'specification-(Ljs-spec),
* cpt.Ljs'specification-(Ljs-spec),
* cpt.Ljs'spec,
* cpt.Ljs'specification-(Ljs-spec),
* cpt.specification.Javascript-(Ljs-spec),

Ljs-spec.SPECIFIC

specific::
* browser-javascript-specification,
===
* ECMA-specification,

Ljs-spec.ECMA-International (Lje)

description::
ECMA-International creates the-specs for Ljs.
ECMA-International creates many standards.
ECMA-262 is the-standard that defines the-ECMAScript-language, as it calls the-ljs.
Specs are-published in pdf or HML format and are texts hard to read and multisemantic.
In current webpage-concept I TRY to describe the-language in monosemantic English by defining most of the-names of my sentences.

name::
* cpt.ECMAScript-(Lje),
* cpt.Lje-(ECMAScript),
* cpt.Ljs'spec.ECMAScript-(Lje),

addressWpg::
* http://www.ecma-international.org/publications/standards/Ecma-262.htm,
* last-standard: http://www.ecma-international.org/ecma-262/index.html,
* draft: https://tc39.github.io/ecma262/,
* issues: https://github.com/tc39/ecma262/issues,

Lje.SPECIFIC

Specific (versions):
* 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),

Lje.ECMAScript.8.2017

description::
ECMAScript-2017 (8th edition).
Pdf-version.
HML-version.

name::
* cpt.ECMAScript.8.2017,
* cpt.ECMA-262-8th-edition,
* cpt.ES2017-(ES8),
* cpt.ES.8.2017,
* cpt.ES8-(ES.2017),
* cpt.Lje.8.2017,
* cpt.Standard.ECMA.262.8-edition,

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,

Lje.ECMAScript.7.2016

description::
ECMAScript-2016 (7th edition).
Pdf-version.
HML-version.

name::
* cpt.ECMAScript.7.2016,
* cpt.ECMA-262-7th-edition,
* cpt.ES2016-(ES7),
* cpt.ES.7.2016,
* cpt.Lje.7.2016,
* cpt.Standard.ECMA.262.7-edition,

Lje.ECMAScript.6.2015

description::
ECMAScript-2015 (6th edition).
Pdf-version.
HML-version.

name::
* cpt.ECMAScript.6.2015,
* cpt.ECMA-262-6th-edition,
* cpt.ES2015-(ES6),
* cpt.ES6-(ES2015),
* cpt.ES.6.2015,
* cpt.Lje.6.2015,
* cpt.Standard.ECMA.262.6-edition,

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

Lje.ECMAScript.5-1.2011

description::
ECMAScript-5.1 is the-version previous to ECMAScript.6.2015, approved on {2011.June}.
My html5.id.toc.preview-version.
Pdf-version.
HML-version.

name::
* cpt.ECMAScript.5-1.2011,
* cpt.ECMAScript-5.1,
* cpt.ECMA-262-5.1-edition,
* cpt.ES.5-1.2011,
* cpt.Lje.5-1.2011,
* cpt.Standard.ECMA.262.51-edition,

tool of Ljs

description::
Any program, used to work with the-language, write, execute, debug, analyze, test the-code.
===
Development tools
Within JavaScript, access to a debugger becomes invaluable when developing large, non-trivial programs. Because there can be implementation differences between the various browsers (particularly within the DOM]), it is useful to have access to a debugger for each of the browsers that a Web application targets.

Script debuggers are integrated within Internet Explorer, Firefox, Safari, Google Chrome, Opera and Node.js.

In addition to the native Internet Explorer Developer Tools, three debuggers are available for Internet Explorer: Microsoft Visual Studio is the richest of the three, closely followed by Microsoft Script Editor (a component of Microsoft Office), and finally the free Microsoft Script Debugger that is far more basic than the other two. The free Microsoft Visual Web Developer Express provides a limited version of the JavaScript debugging functionality in Microsoft Visual Studio. Internet Explorer has included developer tools since version 8.

In comparison to Internet Explorer, Firefox has a more comprehensive set of developer tools, which include a debugger as well. Old versions of Firefox without these tools used a Firefox addon called Firebug, or the older Venkman debugger. Also, WebKit's Web Inspector includes a JavaScript debugger, which is used in Safari. A modified version called Blink DevTools is used in Google Chrome. Node.js has Node Inspector, an interactive debugger that integrates with the Blink DevTools, available in Google Chrome. Last but not least, Opera includes a set of tools called Dragonfly.

In addition to the native computer software, there are online JavaScript IDEs, debugging aids are themselves written in JavaScript and built to run on the Web. An example is the program JSLint, developed by Douglas Crockford who has written extensively on the language. JSLint scans JavaScript code for conformance to a set of standards and guidelines. Many libraries for JavaScript, such as three.js, provide links to demonstration code that can be edited by users. They are also used as a pedagogical tool by institutions such as Khan Academy to allow students to experience writing code in an environment where they can see the output of their programs, without needing any setup beyond a Web browser.

[https://en.wikipedia.org/wiki/JavaScript#Development_tools {2016.08.08}]

name::
* cpt.Ljs'development-tool,
* cpt.Ljs'programing-tool,
* cpt.Ljs'tool,

Ljs-tool.SPECIFIC

name::
* cpt.Ljs'tool.specific,

specific::
* Ljb-tool,
* Ljn-tool,
===
* analysis-tool,
* build-tool,
* debugger-tool,
* editor-tool,
* interpreter-(runtime)-tool,
* package-manager,
* testing-tool,

Ljs-tool.RUNTIME

description::
What is the difference between javascript engine and javascript runtime?
The distinction between the two is not always clear and you'll find that the terms are commonly used interchangeably.
Conceptuallly, the difference is that an engine is responsible for providing the mechanics of parsing and JIT compilation, i.e. producing machine-executable operations from a script written in JavaScript.
The runtime environment provides the built-in libraries that are available to the program at runtime (during execution). So, if you're going to use the Window object or the DOM API in the browser, those would be included in the browser's JS runtime environment. A Node.js runtime includes different libraries, say, the Cluster and FileSystem APIs. Both runtimes include the built-in data types and common facilities such as the Console object.
Chrome and Node.js therefore share the same engine (Google's V8), but they have different runtime (execution) environments.
In a way, the runtime is to the engine what the linker is to the compiler in a traditional compiled language.
[2016-06-24, Alex-Giannakakos, https://www.quora.com/What-is-the-difference-between-javascript-engine-and-javascript-runtime]

name::
* cpt.javascript-runtime-environment,
* cpt.Ljs'runtime,
* cpt.Ljs'tool.runtime-environment,

Ljs-runtime.SPECIFIC

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

Ljs-tool.ENGINE

description::
A JavaScript engine is a program or library which executes JavaScript code.
A JavaScript engine may be a traditional interpreter, or it may utilize just-in-time compilation to bytecode in some manner.
Although there are several uses for a JavaScript engine, it is most commonly used in web browsers.

[https://en.wikipedia.org/wiki/JavaScript_engine {2016.07.25}]

name::
* cpt.Ljs'engine,
* cpt.Ljs'interpreter,
* cpt.Ljs'tool.engine,
* cpt.javascript-engine,
* cpt.javascript-execution-environment,

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

Ljs-engine.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::
* cpt.javascript-engine.SpiderMonkey,
* cpt.Ljs'engine.SpiderMonkey,
* cpt.SpiderMonkey-javascript-engine,

Ljs-engine.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::
* cpt.Google-V8-javascript-engine,
* cpt.javascript'engine.V8,
* cpt.Ljs'V8,
* cpt.Ljs'Google-V8-engine,
* cpt.V8-javascript-engine,

Ljs-tool.CODE-ANALYSIS

description::
When developing JavaScript, a linter is an essential tool for writing robust code.
If you take one thing away from this guide, let it be the use of a linter.
It will point out most issues that are described here and much more.
[https://molily.de/robust-javascript/#linters]

name::
* cpt.code-analysis-tool.javascript,
* cpt.code-beautifier-tool.javascript,
* cpt.code-formatter-tool.javascript,
* cpt.javascript'analysis-tool,
* cpt.javascript'beautifier-tool,
* cpt.javascript'code-analysis-tool,
* cpt.javascript'code-beautifier-tool,
* cpt.javascript'code-formater-tool,
* cpt.javascript'linter,
* cpt.Ljs'analysis-tool,
* cpt.Ljs'linter,
* cpt.Ljs'tool.analysis,

specific::
* Ljn--code-analysis-tool,
===
* ESLint,
* http://jsbeautifier.org/,
* JSHint,
* JSLint,

Ljs-tool.DEBUGGER

description::
All modern browsers come with some form of a built-in JavaScript debugging application.
[https://stackoverflow.com/a/19623573]

name::
* cpt.Ljs'tool.debugger,
* cpt.Ljs'debugger,

addressWpg::
* {2017-09-07} https://codeburst.io/learn-how-to-debug-javascript-with-chrome-devtools-9514c58479db,

Ljs-tool.PACKAGE-MANAGER

description::
Understanding JavaScript Package Managers
There are several JavaScript package managers: npm, bower, volo, ringojs, component. Currently, npm and bower have the most registered packages and enjoy the broadest third-party support.

Npm deals mainly in node-compatible JavaScript modules. However, bower focuses on the entire web platform, offering packages that could contain modules, scripts, CSS stylesheets, HTML templates, images, or fonts. For these reasons, npm tends to be used primarily for node.js development, and bower tends to be the favorite for client-side work.

While npm and bower use incompatible organizational patterns, both may be used in a single project since they use different metadata files (package.json and bower.json), and they install packages into different subdirectories. It's not uncommon to use npm to manage server-side packages and bower to manage client-side packages.

Unlike Java's Maven, JavaScript package managers concentrate mainly on finding packages, installing packages, and managing package versions. Npm also offers the ability to run simple build-related and test-related tasks.

Using JavaScript package managers
Getting started with package managers is straightforward. The following examples are for bower and npm, but similar concepts exist for the others.

After installing bower or npm, type bower init or npm init at the root directory of your project. The package manager will ask several questions. Your answers will be used to create a bower.json or package.json metadata file for your project.

To search for available packages to install, type bower search 'keywords' or npm search 'keywords'. A list of matching packages will be displayed.

To install a package into the local module cache and then copy its latest version into your project, type bower install 'package-name' or npm install 'package-name'. To install a specific version, the syntax varies slightly amongst package managers: bower install 'package-name'#'package-version' or npm install 'package-name'@'package-version'.

You may also save each package's version info into your project's metadata file. The package manager -- as well as other third-party tools -- can use the metadata to simplify client-side maintenance, build, testing, and bootstrapping tasks.

The best way to save a package's version info into your project's metadata file, is to use the --save option while installing the package. Type bower install --save 'package-name'#'package-version' or npm install --save 'package-name'@'package-version'.

[https://spring.io/understanding/javascript-package-managers]

name::
* cpt.Ljs'package-manager,
* cpt.Ljs'tool.package-manager,
* cpt.package-manager.javascript,

Ljspkgmgr.SPECIFIC

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

Ljs-tool.PARSING

name::
* cpt.Ljs'parsing-tool,
* cpt.Ljs'tool.parsing,
* cpt.Ljs'tool.parsing,

addressWpg::
* https://tomassetti.me/parsing-in-javascript/,

Ljs-tool.TESTING

description::
Javascript doesn't support testing natively.

name::
* cpt.Ljs'testing-tool,
* cpt.Ljs'tool.testing,
* cpt.Ljs'tool.testing,

Resource:
* https://www.sitepoint.com/javascript-testing-unit-functional-integration/ {2016.04.25},
* https://github.com/jasmine/jasmine,

specific::
* Ljb-testing-tool,
* Ljn-testing-tool,

GENERIC of Ljs

generic-chain::
* programing-language,
* computer-language,
* mapping-method,
* method,
* ModelConceptStructured,
* info,
* model,
* entity,

Ljs.SPECIFIC

name::
* cpt.Ljs.specific,
* cpt.Ljs'dialect,

description::
A-javascript-dialect is a-programing-language with most of the-characteristics of Ljs, that a-programer 'speaks' and a-computer 'understands'.
If there is no a-compiler|interpreter there is no programing-language.
Today our theories about the-languages (human or computer) are incorrect to a significant extent, but the-languages exist before our theories about them.
ECMAScript, from this point of view, is not a-language, it is a-theory about Ljs.

specific::
* Browser-javascript,
* BrowserNo-javascript,
* Desktop-javascript,
* Node-javascript,
* Server-javascript,
* ServerNo-javascript,
* Strict-javascript,
* StrictNo-javascript,

addressWpg::
* {2017-06-21} JavaScript for Microcontrollers and IoT: https://auth0.com/,

Ljs.Browser-javascript (Ljb {1995}) (Link)

Ljs.Node-javascript (Ljn, Node.js {2009}) (Link)

Ljs.Desktop-javascript (Ljd)

Cpt-created: {2017-07-09}

Ljd'Description

description::
Desktop-javascript (Ljd) is the-javascript for the-desktop.
Browser-js has no full access of the underline operating-system for security reasons.
Node-js has no GUI components.
Desktop-javascript combines the two technologies and creates cross-platform programs using only web-technologies, javascript, HTML and CSS.

name::
* cpt.Desktop-javascript-language-(Ljd),
* cpt.Desktop-js-(javascript-for-desktop-programs),
* cpt.Language.javascript.desktop-(Ljd),
* cpt.Language.progaming.javascript.desktop-(Ljd),
* cpt.Ljd-(LanguageJavascriptDesktop),
* cpt.programing-language.javascript.desktop,

Ljd'Generic-chain

generic-chain::
* javascript-programing-language,
* programing-language,
* computer-language,
* mapping-method,
* method,
* info,
* model,
* entity,

Ljd.SPECIFIC

generic-chain::
* Electron-(Ljel),
* NW.js-(Ljnw),

Ljs.EVOLUTING

name::
* cpt.javascript.evoluting,
* cpt.Ljs.evoluting,

{time.2015}:
=== Node.js v4.0:
In September 2015, Node.js v0.12 and io.js v3.3 were merged back together into Node v4.0.
This brought V8 ES6 features into Node.js, and a long-term support release cycle.
As of 2016, the io.js website recommends that developers switch back to Node.js.

[https://en.wikipedia.org/wiki/Node.js#History]

{time.2013}:
=== ISOMORPHIC-javascript:
In 2013, Airbnb was the first to use Node.js to provide isomorphic (also called universal or simply shared) javascript.
In the Node.js approach, the same framework is identically executed on the server side and client side.
On the server side, it provides an initial render of the page, and data could be provided through Node.js or through REST API calls.
On the client side, the framework binds to DOM elements, "rehydrates" (updates the initial server-side render provided by Node.js) the HTML, and makes asynchronous REST API calls whenever updated data is needed.
The biggest advantage Airbnb's javascript isomorphism had over Twitter's approach is the notion of a completely reusable rendering system.
Because the client-side framework is executed the same way on both server and client, rendering becomes much more manageable and debuggable in that the primary distinction between the server-side and client-side renders is not the language or templating system used, but rather what data is provisioned by the server and how.
From a prototype written in 10 days to being used across the stack by some of the largest websites in the world, long gone are the days of clunky browser implementations whose APIs changed depending on whether you were using Netscape or Internet Explorer.
It took javascript 20 years, but it is finally considered an equal partner to traditional, well-established server-side languages.

[http://buytaert.net/a-history-of-javascript-across-the-stack]

{time.2009}:
=== Node.js:
Node.js was originally written in 2009 by Ryan Dahl.
Dahl demonstrated the project at the inaugural European JSConf on November 8, 2009.
Node.js combined Google's V8 javascript engine, an event loop and a low-level I/O API.
The project received a standing ovation.

[https://en.wikipedia.org/wiki/Node.js#History]

{time.2008}:
=== V8, PERFORMANCE:
In 2008, Google launched Chrome with a faster javascript engine called V8.
The release announcement read:
"We also built a more powerful javascript engine, V8, to power the next generation of web applications that aren't even possible in today's browsers.".
At the launch, V8 improved javascript performance by 10x over Internet Explorer by compiling javascript code to native machine code before executing it.
This caught my attention because I had recently finished my PhD thesis on the topic of JIT compilation.
More importantly, this marked the beginning of different browsers competing on javascript performance, which helped drive javascript's adoption.

[http://buytaert.net/a-history-of-javascript-across-the-stack]
=== JIT:
In 2008, a period that people call the performance wars began. Multiple browsers added just-in-time compilers, also called JITs. As JavaScript was running, the JIT could see patterns and make the code run faster based on those patterns.
The introduction of these JITs led to an inflection point in the performance of JavaScript. Execution of JS was 10x faster.
[https://hacks.mozilla.org/2017/02/a-cartoon-intro-to-webassembly/]

{time.2005}:
=== Google Maps, Ajax:
A year later in 2005, Google launched Google Maps, which used the same technology as Gmail to transform online maps into an interactive experience.
With Google Maps, Google was also the first large company to offer a javascript API for one of their services allowing developers to integrate Google Maps into their websites.
Google's XMLHttpRequest approach in Gmail and Google Maps ultimately came to be called Ajax (originally "Asynchronous javascript and XML").
Ajax described a set of technologies, of which javascript was the backbone, used to create web applications where data can be loaded in the background, avoiding the need for full page refreshes.
This resulted in a renaissance period of javascript usage spearheaded by open source libraries and the communities that formed around them, with libraries such as Prototype, jQuery, Dojo and Mootools.
(We added jQuery to Drupal core as early as 2006.)

[http://buytaert.net/a-history-of-javascript-across-the-stack]

{time.2004}:
=== Gmail:
For the first 10 years of javascript's life, professional programmers denigrated javascript because its target audience consisted of "amateurs".
That changed in 2004 with the launch of Gmail.
Gmail was the first popular web application that really showed off what was possible with client-side javascript.
Competing e-mail services such as Yahoo! Mail and Hotmail featured extremely slow interfaces that used server-side rendering almost exclusively, with almost every action by the user requiring the server to reload the entire web page.
Gmail began to work around these limitations by using XMLHttpRequest for asynchronous data retrieval from the server.
Gmail's use of javascript caught the attention of developers around the world.
Today, Gmail is the classic example of a single-page javascript app; it can respond immediately to user interactions and no longer needs to make roundtrips to the server just to render a new page.

[http://buytaert.net/a-history-of-javascript-across-the-stack]

{time.1995}:
=== ANNOUNCEMENT:
MOUNTAIN VIEW, Calif. (December 4, 1995) -- Netscape Communications Corporation (NASDAQ: NSCP) and Sun Microsystems, Inc. (NASDAQ:SUNW), today announced javascript, an open, cross-platform object scripting language for the creation and customization of applications on enterprise networks and the Internet.
The javascript language complements Java, Sun's industry-leading object-oriented, cross-platform programming language.
The initial version of javascript is available now as part of the beta version of Netscape Navigator 2.0, which is currently available for downloading from Netscape's web site.

[https://web.archive.org/.../wp.netscape.com/newsref/pr/newsrelease67.html]

meta-info

This page was visited times since {2016.05.04}

Page-wholepath: synagonism.net / Mcs-worldview / dirTechInfo / javascript (Ljs)

SEARCH::
This page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
LOCAL-SEARCH:
Type CTRL+F "cpt.words-of-concept's-name", to go to the-LOCATION of the-concept.
GLOBAL-SEARCH:
Clicking on the-green-TITLE of a-page you have access to the-global--locator-names of my-site.
A-preview of the-description of a-global-name makes reading fast.
Abbreviations have no description.

Footer:
• author: Kaseluris.Nikos.1959
• email:
 imgMail
• twitter: @synagonism
===
• github: https://github.com/synagonism/Mcsw/blob/master/dirTchInf/FilMcsLjs.Last.html,

SEARCH THE-PAGE:
This page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
Type CTRL+F "cpt.[ljs|ljb|ljn]words-of-concept's-name", to go to the-LOCATION of the-concept.
There are about 400 sub-concepts in this concept (ebook) with 1,400 names and 14,000 lines of hitp-document.

Webpage-Versions:
• version.dynamic: FilMcsLjs.Last.html,
• version.5-0-0.2017-11-26.last: filMcsLjs.5-0-0.2017-11-26.html,
• version.4.2017-07-11: filMcsLjs.4.2017-07-11.html,
• version.3.2016-08-22 (2-4): filMcsLjs.3.2016-08-22.html,
• version.2.2016-08-04.ljs-ljn (1-33): filCptLjs.2.2016-08-04.html,
• version.1-21.2016-05-26: lngJs.1-21.2016-05-26.html,
• version.1-17.2016-05-23: lngJs.1-17.2016-05-23.html,
• version.1-11.2016-05-18: lngJs.1-11.2016-05-18.html,
• version.1.2016-05-10.ljb.created: lngJs.1.2016-05-10.html,

Support (Link)

Comments

specific::
* on Disqus,
* on Steemit,