Please enable JavaScript.

Coggle requires JavaScript to display documents.

JavaScript - Coggle Diagram

- - - - Program: A set of instructions for a computer
      - Programming Language: Artificial language used to instruct computer
      - Code: The text that makes up programs
        
        Expression: A fragment of code that produces a value
        
        E. g. 22 or “test” or
        
        Statement: Line of Code
        
        E.g. true;
    - - Number: Numeric values with max chunk size of 64bits
        
        Special Numbers
        
        Infinity, -Infinity
        
        NaN: not a number
        
        Immutable: It’s impossible to change values of those types. They can be combined, derived but the value inside a String, Number, Boolean can’t change.
      - String: Is used to represent Text. It is declared with quotes ‘’ “” ``
        
        Escape characters: Are characters with a special meaning in JS they can be used as normal characters in strings by putting a \ in-front of them
        
        \n: New line
        
        \t: Tab
        
        \ \: \
        
        Concatenation: Glueing together two strings. “A” + “b” will be “Ab”
        
        Template literals: Strings that can span lines and embed other values.
        
        ` This is a template literal with an value of ${number} `
      - Empty Values: denote the absence of a meaningful values
        
        Undefined
        
        Null
      - Function: A piece of program wrapped in a value. E.g. function(parameter) {body}
        
        Argument: Value given to a function
        
        If less arguments are handed to a function than expected, the missing arguments will be assigned the default value of undefined
        
        Body: Contains the code of the function
        
        Declaration: Function declarations are not part of the toptobottom flow of a program and are conceptually always moved to the top of a scope even if they appear later, meaning they can be accessed by code before they are declared (aka hoisting)
        
        Let return10 = function() {return 10;};
        or
        function return10() {return 10;}
        
        Lamda/ Arrow Functions: (parameter, paramerter) => {body};
        If there’s one parameter the brackets can be omitted.
        If there’s only one return statement the body can be omitted.
        number => number2; is the same as
        (number) => {return number 2;};
        
        Parameter: Expected agrument
        
        If a = is written behind a parameter it will indicate a default value
        
        Closure: Referencing a local variable through a enclosing binding
        
        Function warp (n){ let local = n; return n;}
        let enclosingBinding = warp(1);
        enclosingBinding(); --> 1
        
        Recursion: A function that calls itself
      - Boolean: True or false values
      - Objects: Are a arbitrary collection of properties. Are created via { propertyName : value, propertyName : value}
        
        Properties: Are default values/ functions of an object. All values have properties except null and undefined. They can be accessed either via value.x or via value[x]. Both access a property x but not necessarily the same. .x points to a property named x whereas [x] will be evaluated, x could be a variable holding the name of the property
        
        Property names are stored as strings, meaning the same rules as for bindig names apply or else they can’t be accessed via the dot notation.
        
        PropertyNames whose names aren’t valid bindings must be quoted, e.g. {“love message” : “This is a love message”, loveMessage: “ This is a love message”
        
        Methods: Properties containing functions
        
        Accessing a property that doesn’t exist will return undefined. Properties can be assigned a values via = . This will replace the value of an property or create a new property when no property exists
    - - Scope: The part of the program in which the binding is visible. Can be nested, functions and blocks{} will be a scope
        
        Global: Visible in the whole program
        
        Local: Only visible inside the current scope and all scopes contained in that
      - Let: used for bindings contained to their scope
      - Const: used for bindings that never hold other values
      - Var: used for bindings visible in the whole program
      - E.g. let number = 10;
        const secondsInMinute = 60;
      - Identity: Two objects grasping the same value have the same identity. E.g.
        let object1 = {value: 10}
        let object2 = object1
  - - - Comparison ? 1 : 2
        
        If true 1 is returned, if false 2 is returned
    - - 0, NaN, undefined, null, “” count as false, everything else will return true
      - The == operator will only result in true when to objects share the same identiy
    - - Can be used for replacing an empty value because an empty value is equal to false. E.g. null || “user” -> user
  - - - do{}while(condition): Same as while loop except the code is executed at least once before the condition is evaluated
    - - Array Loops: Will cycle through all elements of an object.
        for (let entry in array){}
- - - - indexOf begins at the front of an array, .lastIndexOf(element) starts at the back