Please enable JavaScript.

Coggle requires JavaScript to display documents.

JS - get started - Coggle Diagram

- - - - that means you can write procedural, OO or functional
  - - - Backwards compatibility means that once something is accepted as valid JS, there will not be a future change to the language that causes that code to become invalid JS.
        
        Gaps between code you write and the oldest engine
        
        transpiler - Babel - to convert from that newer JS syntax version to an equivalent older syntax.
        
        Transpilation and polyfilling
  - - - program leaves developer's editor
        
        gets delivered to JS engine
        
        JS engine parses code to an AST (Abstract Syntax Tree)
        
        engine converts that AST to a kind-of byte code, a binary intermediate representation (IR)
        
        which is then refined/converted even further by the optimizing JIT compiler
        
        Finally, the JS VM executes the program.
  - - - using: map, filter, reduce...
- - - - They mix together in this global scope namespace, so at runtime they act as a whole.
  - - - JS does in fact still treat each module separately. Similar to how "global scope" allows standalone files to mix together at runtime, importing a module into another allows runtime interoperation between them.
  - - - number
        
        Math.PI
        
        bigint - storing arbitrarily large numbers
      - null
      - booleans
      - undefined
      - string
      - symbol
        
        special-purpose value that behaves as a hidden unguessable value. Symbols are almost exclusively used as special keys on objects
    - - arrays
    - - typeof null; //"object" - bug
  - - - block scoped
    - - block scoped;
      - value cannot be re-assigned later
      - using only with primitive values - avoid confusion of re-assignment
  - - - NaN === NaN //false
        
        use: Number.isNaN()
      - 0 === -0 //true
        
        use: Object.is()
      - comparing objects //false
        
        === uses identity equality
        
        object held by reference
    - - a value of one type being converted to its respective representation in another type
  - - - new keyword
      - custom data structure that includes both data and behaviors that operate on that data
      - class inheritance
        
        extends
        
        super(..)
        
        polymorphism
        
        inherited and overridden methods can have the same name and co-exist
- - - - A Map data structure uses objects as keys, associating a value (of any type) with that object. Maps have a different default iteration than seen here, in that the iteration is not just over the map's values but instead its entries. An entry is a tuple (2-element array) including both a key and a value
    - - keys()
      - values()
      - entries()
  - - - dependent on how it is called
  - - - linkage between two objects
        
        Object.create(..)
        
        Object.create(null) - not prototype linked anywhere
      - prototype chain
        
        series of objects liked together
      - delegation of prop/methods access allows objecst to cooperate
      - Object.prototype
        
        build-in methods: toString(), valueOf()...
- - - - hoisting
      - function scoped var
  - - - objects cooperate through the prototype chain (forget classes altogether)