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 - Extended Parameter Handling, Template Literals

    Published Oct 07, 2019 [  Node.js  ]

    Extended Parameter Handling

    Default Parameter Values

    Simple and intuitive default values for function parameters.

    function f (x, y = 7, z = 42) {
        return x + y + z
    }
    f(1) === 50
    

    Rest Parameter

    Aggregation of remaining arguments into single parameter of variadic functions.

    function f (x, y, ...a) {
        return (x + y) * a.length
    }
    f(1, 2, "hello", true, 7) === 9
    

    Spread Operator

    Spreading of elements of an iterable collection (like and array or even a string) into both literal elements and individual function parameters.

    var params = [ "hello", true, 7 ]
    var other = [ 1, 2, ...params ] // [ 1, 2, "hello", true, 7 ]
    
    function f (x, y, ...a) {
        return (x + y) * a.length
    }
    f(1, 2, ...params) === 9
    
    var str = "foo"
    var chars = [ ...str ] // [ "f", "o", "o" ]
    

    Template Literals

    String Interpolation

    Intuitive expression interpolation for single-line and multi-line strings.

    var customer = { name: "Foo" }
    var card = { amount: 7, product: "Bar", unitprice: 42 }
    var message = `Hello ${customer.name},
    want to buy ${card.amount} ${card.product} for
    a total of ${card.amount * card.unitprice} bucks?`
    

    Custom Interpolation

    Flexible expression interpolation for arbitrary methods.

    get`https://example.com/foo?bar=${bar + baz}&quux=${quux}`
    

    Raw String Access

    Access the raw template string content (backslashes are not interpreted)

    function quux (strings, ...values) {
        strings[0] === "foo\n"
        strings[1] === "bar"
        strings.raw[0] === "foo\\n"
        strings.raw[1] === "bar"
        values[0] === 42
    }
    quux`foo\n${ 42 }bar`
    
    String.raw`foo\n${ 42 }bar` === "foo\\n42bar"
    

    References: