up

1-js/4-object-basics/04-object-methods/8-chain-calls/_js.view/solution.js

@@ -0,0 +1,15 @@
+
+let ladder = {
+  step: 0,
+  up: function() { 
+    this.step++;
+    return this;
+  },
+  down: function() { 
+    this.step--;
+    return this;
+  },
+  showStep: function() { 
+    alert(this.step);
+  }
+};

1-js/4-object-basics/04-object-methods/8-chain-calls/_js.view/test.js

@@ -0,0 +1,40 @@
+
+describe('Ladder', function() {
+  before(function() {
+    window.alert = sinon.stub(window, "alert");
+  });
+  
+  beforeEach(function() {
+    ladder.step = 0;
+  });
+
+  it('up() should return this', function() {
+    assert.equal(ladder.up(), ladder);
+  });
+
+  it('down() should return this', function() {
+    assert.equal(ladder.down(), ladder);
+  });
+
+  it('showStep() should call alert', function() {
+    ladder.showStep();
+    assert(alert.called);
+  });
+
+  it('up() should increase step', function() {
+    assert.equal(ladder.up().up().step, 2);
+  });
+
+  it('down() should decrease step', function() {
+    assert.equal(ladder.down().step, -1);
+  });
+
+  it('down().up().up().up() ', function() {
+    assert.equal(ladder.down().up().up().up().step, 2);
+  });
+  
+  after(function() {
+    ladder.step = 0;
+    alert.restore();
+  });
+});

1-js/4-object-basics/04-object-methods/8-chain-calls/solution.md

@@ -0,0 +1,40 @@
+The solution is to return the object itself from every call.
+
+```js run
+let ladder = {
+  step: 0,
+  up() {
+    this.step++;
+*!*
+    return this;
+*/!*
+  },
+  down() {
+    this.step--;
+*!*
+    return this;
+*/!*
+  },
+  showStep() {
+    alert( this.step );
+*!*
+    return this;
+*/!*
+  }
+}
+
+ladder.up().up().down().up().down().showStep(); // 1
+```
+
+We also can write a single call per line. For long chains it's more readable:
+
+```js 
+ladder
+  .up()
+  .up()
+  .down()
+  .up()
+  .down()
+  .showStep(); // 1
+```
+

1-js/4-object-basics/04-object-methods/8-chain-calls/task.md

@@ -0,0 +1,39 @@
+importance: 2
+
+---
+
+# Chaining
+
+There's a `ladder` object that allows to go up and down:
+
+```js
+let ladder = {
+  step: 0,
+  up() { 
+    this.step++;
+  },
+  down() { 
+    this.step--;
+  },
+  showStep: function() { // shows the current step
+    alert( this.step );
+  }
+};
+```
+
+Now, if we need to make several calls in sequence, can do it like this:
+
+```js
+ladder.up();
+ladder.up();
+ladder.down();
+ladder.showStep(); // 1
+```
+
+Modify the code of `up` and `down` to make the calls chainable, like this:
+
+```js
+ladder.up().up().down().showStep(); // 1
+```
+
+Such approach is widely used across Javascript libraries.