Tags

  • AWS (7)
  • Apigee (3)
  • ArchLinux (5)
  • Array (6)
  • Backtracking (6)
  • BinarySearch (6)
  • C++ (19)
  • CI&CD (3)
  • Calculus (2)
  • DesignPattern (43)
  • DisasterRecovery (1)
  • Docker (8)
  • DynamicProgramming (20)
  • FileSystem (11)
  • Frontend (2)
  • FunctionalProgramming (1)
  • GCP (1)
  • Gentoo (6)
  • Git (15)
  • Golang (1)
  • Graph (10)
  • GraphQL (1)
  • Hardware (1)
  • Hash (1)
  • Kafka (1)
  • LinkedList (13)
  • Linux (27)
  • Lodash (2)
  • MacOS (3)
  • Makefile (1)
  • Map (5)
  • MathHistory (1)
  • MySQL (21)
  • Neovim (10)
  • Network (66)
  • Nginx (6)
  • Node.js (33)
  • OpenGL (6)
  • PriorityQueue (1)
  • ProgrammingLanguage (9)
  • Python (10)
  • RealAnalysis (20)
  • Recursion (3)
  • Redis (1)
  • RegularExpression (1)
  • Ruby (19)
  • SQLite (1)
  • Sentry (3)
  • Set (4)
  • Shell (3)
  • SoftwareEngineering (12)
  • Sorting (2)
  • Stack (4)
  • String (2)
  • SystemDesign (13)
  • Terraform (2)
  • Tree (24)
  • Trie (2)
  • TwoPointers (16)
  • TypeScript (3)
  • Ubuntu (4)
  • Home

    A Review of ES6 - Constants, Scoping, Arrow Functions

    Published Oct 06, 2019 [  Node.js  ]

    Constants

    Constants

    Support for constants (also known as “immutable variables”), i.e., variables which cannot be re-assigned new content. Notice: this only makes the variable itself immutable, not its assigned content (for instance, in case the content is an object, this means the object itself can still be altered).

    const PI = 3.141593
    PI > 3.0
    

    Scoping

    Block-Scoped Variables

    Block-scoped variables (and constants) without hoisting.

    for (let i = 0; i < a.length; i++) {
        let x = a[i]
        
    }
    for (let i = 0; i < b.length; i++) {
        let y = b[i]
        
    }
    
    let callbacks = []
    for (let i = 0; i <= 2; i++) {
        callbacks[i] = function () { return i * 2 }
    }
    callbacks[0]() === 0
    callbacks[1]() === 2
    callbacks[2]() === 4
    

    Block-Scoped Functions

    {
        function foo () { return 1 }
        foo() === 1
        {
            function foo () { return 2 }
            foo() === 2
        }
        foo() === 1
    }
    

    Arrow Functions

    Expression Bodies

    More expressive closure syntax.

    odds  = evens.map(v => v + 1)
    pairs = evens.map(v => ({ even: v, odd: v + 1 }))
    nums  = evens.map((v, i) => v + i)
    

    Statement Bodies

    More expressive closure syntax.

    nums.forEach(v => {
       if (v % 5 === 0)
           fives.push(v)
    })
    

    Lexical this

    More intuitive handling of current object context.

    this.nums.forEach((v) => {
        if (v % 5 === 0)
            this.fives.push(v)
    })
    

    References: