Have been in a situation where you needed to dynamically shoot out HTTP requests based on some branching logic? Are you using a Promise based HTTP client library like fetch or axios?
Fear not, here is a solution for your needs!
In general the solution is based on coming up with an interface that's not only returning the data when the Promise was resolved, but also give a companion flag that identifies the promise it was initiated from.
You can find the idea on this SO post as well.
var parent = {
get: function fn(){
return this.val;
},
val:42
};
var child = Object.create(parent);
child.val = 69;
var grandchild = Object.create(child);
parent.get(); //42
child.get(); //69
grandchild.get(); //69
E.g. what happens at the child.get(); call? The value attribute is set to 69. That's clear. But what will be it's get function? Here comes the cool part. Obviously the child object does not implement any get functions, so the JavaScript engine will seek for it in the prototype chain. It will go back to it's prototype object (an dif there is no implementation of get, it will look at it's prototype, etc.. That's what we call 'prototype chain'.), and call it's get function, however the this keyword is going to reference to the child object. Pretty neat, isn't it?var greatgrandchild = Object.create(grandchild);
greatgrandchild.get = function() {
return this.val + " is my val."
};
greatgrandchild.get(); //"69 is my val."
Also we can create a contructor in an object:var MyObject = {
constructor: function(value) {
this._val = value;
},
get: function() {
return this._val;
}
};
MyObject.constructor(42);
MyObject.get(); //42
new.var XXX = function() {
console.log("Here I am, sitting on a tree.");
};
XXX.prototype.constructor; //function () {console.log("Here I am, sitting on a tree.");}
var x = new XXX(); //"Here I am, sitting on a tree."
//class Animal
var Animal = function(_feet) {
this.feet = _feet;
};
Animal.prototype.eat = function() {
console.log("I am eating, omnomnom..");
};
Animal.prototype.info = function() {
console.log("I have this amount of feet: " + this.feet);
};
//class Cat extends Animal
var Cat = function(_feet, _miceHaveEaten) {
Animal.call(this, _feet);
this.miceHaveEaten = _miceHaveEaten;
var privateVariable = "This is not available outside the class!";
};
Cat.prototype = new Animal();
Cat.prototype.purr = function() {
console.log("Purrrrrr.........");
};
//polymorphism
Cat.prototype.info = function() {
console.log("I have eaten this amount of mice so far: " + this.miceHaveEaten + ", also I have " + this.feet + " feet.");
};
var unicellular = new Animal(0);
unicellular.eat();
unicellular.info();
var cico = new Cat(4, 9001);
cico.eat();
cico.purr();
cico.info();
this, it is going to be assigned to every instance of the class. Typically we don't want to do this, so we want to assign it only to the class's prototype.Cat. This can be done by easily using the var keyword, not using the reference to the object with the this keyword.this with the '=' operator. If you want to do a call like the following: this="this"; , the browser will give a ReferenceError: Invalid left-hand side in assignment. error.//class Orc
var Orc = function(_ugliness) {
if (_ugliness > 0 && _ugliness < 100) {
this.ugliness = _ugliness;
} else {
this.ugliness = 100;
}
};
Orc.prototype.intimidate = function() {
console.log("You will fear me cuz my ugliness index is: " + this.ugliness);
};
//class UrukHai extends Orc
var UrukHai = function(_ugliness, _strongness) {
Orc.call(this, _ugliness);
if (_strongness > 0 && _strongness < 10) {
this.strongness = _strongness;
} else {
this.strongness = 0;
}
};
UrukHai.prototype = new Orc();
UrukHai.prototype.attack = function() {
console.log("I will crush you cuz my ugliness index is " + this.ugliness + ", and my strongness is: " + this.strongness);
};
import java.util.*;
public class Adam {
public static void main(String[] args){
String adam = "adam";
Integer notPrimitiveInteger = 10;
int primitiveInteger = 20;
ArrayList arrList = new ArrayList();
arrList.add(1);
arrList.add(2);
doSomething(adam,notPrimitiveInteger,primitiveInteger,arrList);
System.out.println(adam);
System.out.println(notPrimitiveInteger);
System.out.println(primitiveInteger);
System.out.println(arrList.size());
}
private static void doSomething(String adam,Integer notPrimitiveInteger,int primitiveInteger,ArrayList arrList){
adam = "notAdam";
notPrimitiveInteger = 500;
primitiveInteger = 7000;
arrList.add(3);
}
}
//Ignore this line :)
And the output is:blabla = "blabla";
var adam = new String("adam");
var integ = 10;
var arr = new Array();
arr.push(1);
arr.push(2);
arr.push(3);
var obj = new Object();
obj.adam = "oldValue";
console.log(arr);
doSomething(adam,integ,arr,obj);
function doSomething(adam,inte,arr,obj){
adam="notadam";
inte="500";
arr.pop();
obj.adam="newValue";
}
console.log(adam);
console.log(integ);
console.log(arr);
console.log(obj);
And the output is: