When I use classes, when I don’t, what I do instead and why(blog.kentcdodds.com)

  async.timeout(server.close, 60000)(exit)

  async.timeout(cb => server.close(cb), 60000)(exit)

  class FooClass {
    constructor (bar) { this.bar = bar; }
    getBar () { return this.bar; }
    setBar (bar) { this.bar = bar; }
  }

  function FooClosure (bar) {
    var _bar = bar;
    return {
      getBar () { return _bar; },
      setBar (bar) { _bar = bar; }
    };
  }

  function FooPrototype (bar) { this.bar = bar; }
  FooPrototype.prototype.getBar = function () { return this.bar; };
  FooPrototype.prototype.setBar = function (bar) { this.bar = bar; };

  class Foo {
    bar = () => {
      console.log(this);
    }
  }

    class Foo {
      bar = () => {
        console.log(this);
      }
    }

    // In web browsers, the window object is also the global object:
    console.log(this === window); // true

    a = 37;
    console.log(window.a); // 37

    this.b = "MDN";
    console.log(window.b)  // "MDN"
    console.log(b)         // "MDN"

   function f1() {
      return this;
    }
    
    // In a browser:
    f1() === window; // true 
    
    // In Node:
    f1() === global; // true

    function f2() {
      'use strict'; // see strict mode
      return this;
    }
    
    f2() === undefined; // true

    function f() {
      return this.a;
    }
    
    var g = f.bind({a: 'azerty'});
    console.log(g()); // azerty
    
    var h = g.bind({a: 'yoo'}); // bind only works once!
    console.log(h()); // azerty

    var globalObject = this;
    var foo = (() => this);
    console.log(foo() === globalObject); // true

    var o = {
      prop: 37,
      f: function() {
        return this.prop;
      }
    };
    
    console.log(o.f()); // 37

    var o = {prop: 37};
    
    function independent() {
      return this.prop;
    }
    
    o.f = independent;
    
    console.log(o.f()); // 37

    <button
      Show this
    </button>

    <button { return this; })());">
      Show inner this
    </button>

    class A{ 
        int data; 
        void method1(int input){data = input;}
        }
    A my_instance;

    struct A {int data;}
    method1_for_struct_A(A *context, int input){ context->data = input; } //normal local function
    A my_instance;

    my_instance.method1(3);

    method1_for_struct_A(my_instance, 3); 
    //send a pointer to the class we're operating on

    //note: global function, NOT apart of any class.
    delegate void my_function(int input)
        {
        data = input; //where is data coming from?
       // the surrounding context.
        }

    void my_test_function()
        {
        int data = 2;
        my_function(3); // is a delegate and gets implicitly sent the context 
        //pointer for my_test_function, and now, it can access data.
        // Note this is a RUN-TIME adjustable function. Delegates can be passed
        // around. 
        }

    void my_function(context_pointer, int input)
        {
        context_pointer.data = input;
        }

    my_function(3) becomes
    my_function(my_test_function_context, 3);