Création d'une Task Arithmétique Runner

voix
0

J'ai été chargé de créer une Arithmétique Task Runner dans le cadre de ma mission.

Jusqu'à aujourd'hui, je ne l'ai jamais utilisé NodeJS ou même le terminal pour exécuter un script.

Je travaille sur cette question depuis les 5 dernières heures et toujours pas de chance. Je l'ai évité de venir ici et de demander que je voudrais le comprendre pour moi, cependant, j'ai succombé à désespérément besoin d'aide.

Ceci est le code que j'ai jusqu'à présent:

class ArithmeticTaskRunner {
    static set taskCount(counter) {
        throw new('This is a readOnly accessor, the value is ${value}');
    }

    add(y) {
        this.y = y || 0
        console.log(y)
        }

         minus(x) {
            this.x = Math.abs(this.y) * -1;
            console.log(this.x);
        };

    multiply(z) {
        this.z = z * this.x;
        console.log(this.z)
    }

    execute(startValue) {
       this.startValue = startValue + this.y
       this.y = this.startValue
        console.log(this.startValue)
        this.startValue = this.minus
        console.log(this.startValue)
        this.startValue = this.multiply(this.startValue)
        console.log(this.startValue)
    }
}

tasks = [
    function() { minus()},
    function() { multiply(z)},  
    function() { add(x)},
    function() { execute(x)}    
]

Ceci est loin d'être parfait, mais il est de 80% -90% d'achèvement.

Telle est la tâche m'a été donné:

You should implement a class called ArithmeticTaskRunner with the following:
- An instance variable named tasks which is initialised to an empty array upon
creation.
- A method named addNegationTask which adds an anonymous function to the
tasks array. This anonymous function should take one argument, x, and return the
negation, -x.
- A method named addAdditionTask which takes a single argument y, and adds
an anonymous function to the tasks array. This anonymous function should take
one argument, x, and return the result x + y.
- A method named addMultiplicationTask which takes a single argument y,
and adds an anonymous function to the tasks array. This anonymous function
should take one argument, x, and return the result x * y.
- A read-only accessor named taskCount which returns the number of queued tasks.
- A method named execute, which takes a single argument named startValue.
If omitted, startValue defaults to zero. Starting at startValue, this method should iterate over the tasks array executing each function on the current value. It then returns the resulting number after all arithmetic operations have been executed.

Je serais reconnaissant pour toute aide que je pouvais obtenir.

Les questions que je sont les suivantes: La méthode d' exécution ( en essayant de faire le startValue, après l'addition, un négatif), la méthode de multiplication et le fait que je ne peux pas appeler la méthode d'addition deux fois sans écraser la valeur. Les exemples du programme ont montré que je pleinement de travail devrait permettre une méthode à appeler plusieurs fois sans écraser la valeur précédente.

Je sais qu'il ya une règle où il est une question par question, je concède. Mais si quelqu'un peut me aider avec l'une des questions que je serai vraiment reconnaissant et j'indemniser les gens pour leurs efforts.

Je vous remercie.

Edit - Ceci est un exemple des deux entrées / sorties attendues

> let taskRunner = new ArithmeticTaskRunner()
undefined
> taskRunner.addAdditionTask(2)
undefined
> taskRunner.addMultiplicationTask(4)
undefined
> taskRunner.addAdditionTask(10)
undefined
> taskRunner.execute(2)
26
> taskRunner.execute(-2)
10
Créé 07/11/2018 à 20:06
source utilisateur
Dans d'autres langues...                            


1 réponses

voix
1

Je ne veux pas donner toute réponse , car cela est une mission pour vous, mais voici un code qui pourrait vous aider. Cela commence par 5puis appelle doubleItet appelle ensuite addOnearriver à 11.

Elle le fait en créant un éventail de fonctions, chacun effectue une tâche simple et renvoie le résultat de son entrée modifiée d'une certaine façon.

Ensuite , il crée une fonction appelée executequi utilise Array.reduce pour appeler la première fonction dans le tableau avec une valeur initiale donnée, puis à plusieurs reprises chaque fonction appelle dans le tableau sur le résultat. Consultez la documentation Array.reduce si vous êtes confus au sujet de la façon dont cela fonctionne.

doubleIt = x => x * 2;
addOne = x => x + 1;
tasks = [doubleIt, addOne];
execute = (initial) => tasks.reduce((x,fn) => fn(x), initial)
document.write(execute(5))

Astuce n ° 2

class ArithmeticTaskRunner {
  constructor() {
    this.tasks = [];
  }
  
  addAdditionTask(arg) {
    this.tasks.push(x => x + arg);
  }
    
  addMultiplicationTask(arg) {
    this.tasks.push(x => x * arg);
  }
  
  execute(startValue) {
    return this.tasks.reduce((x, fn) => fn(x), startValue);
  }
}

let taskRunner = new ArithmeticTaskRunner()
taskRunner.addAdditionTask(2)
taskRunner.addMultiplicationTask(4)
taskRunner.addAdditionTask(10)
document.write(taskRunner.execute(2));
document.write(', ');
document.write(taskRunner.execute(-2));

Créé 07/11/2018 à 20:33
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more