Anfänger JavaScript-OOP vs Funktionale

Programmier-Paradigma

Objektorientierte Programmierung (OOP) und Functionnal Programmierung (FP) sind Programmier-Paradigmen. Grob gesagt, die folgenden ein Programmier-Paradigma ist das schreiben von code-kompatibel mit einem bestimmten set von Regeln. Zum Beispiel die Organisation den code in Einheiten, die aufgerufen werden würde, OOP, Vermeidung von Nebenwirkungen genannt werden würde FP.

Jeder Programmier-Paradigma ist aus der spezifischen Funktionen, jedoch Ihre bevorzugte Sprache nicht haben, um alle Funktionen zu fallen, in ein Paradigma. In der Tat, OOP Leben können, ohne Vererbung oder Kapselung, so können wir sagen, dass JavaScript (JS) ist eine OOP-Sprache mit Vererbung und ohne Kapselung.

Jetzt haben Sie ein wenig Verständnis dafür, was für ein Programmier-Paradigma ist (hoffentlich), haben wir einen kurzen Blick auf die Grundlagen von OOP und FP.

Objektorientierte Programmierung

In OOP ein Objekt ist eine box mit Informationen und Vorgänge werden soll, beziehen sich auf das gleiche Konzept. Informationen sind Häufig bekannt als "Attribute", und Operationen sind Häufig bekannt als "Methoden". Attribute erlauben, zu verfolgen, den Zustand des Objekts und Methoden erlauben es, zu manipulieren, um den Zustand des Objekts.

In JS-können Sie senden eine Nachricht an ein Objekt zur Ausführung einer bestimmten Methode. Der folgende code zeigt, wie eine Methode aufzurufen, die in JS. Die "point" - Objekt hat zwei Attribute, "x" und "y", und eine Methode namens "übersetzen". Die "translate" - Methode aktualisiert die Koordinaten des "point", basierend auf den gegebenen Vektor.

point = {
  x: 10, y: 10,
  translate: function (vector) {
    this.x += vector.x;
    this.y += vector.y;
  }
};

point.x; //10
point.translate({ x: 10, y: 0 });
point.x; //20

Gibt es nicht viele Funktionen beteiligt, die in einem so einfachen Fall. In OOP-code ist oft unterteilt in Klassen, und in der Regel unterstützt die Vererbung und Polymorphismus. Aber ich will nicht weiter ins Detail gehen, da ich fürchte, ich bin schon außerhalb der Reichweite Ihrer Frage.

Funktionale Programmierung

In der FP, der code ist im wesentlichen eine Kombination von Funktionen. Außerdem werden die Daten unveränderlich ist, die dazu führt, das schreiben von Programmen mit keine Nebenwirkungen. In funktionalen code, eine Funktion ist nicht in der Lage zu ändern, die außerhalb der Welt, und der Ausgangswert hängt nur von den angegebenen Argumenten. Diese können starke Kontrolle über den Programmablauf.

Eigentlich JS kann verwendet werden, als ein FP-Sprache so lange, wie Sie kümmern sich um Nebenwirkungen, gibt es keinen eingebauten Mechanismus für, die. Der folgende code ist ein Beispiel für einen solchen Programmierstil. Die "zipWith" - Funktion kommt von der Haskell Welt. Es führt zwei Listen mit der gegebenen Funktion, wie es geschieht, add(point[i], vector[i]).

zipWith = function (f, as, bs) {
  if (as.length == 0) return [];
  if (bs.length == 0) return [];
  return [f(as[0], bs[0])].concat(
    zipWith(f, as.slice(1), bs.slice(1))
  );
};

add = function (a, b) {
  return a + b;
};

translate = function (point, vector) {
  return zipWith(add, point, vector);
};

point = [10, 10];
point[0]; //10
point = translate(point, [10, 0]);
point[0]; //20

Diese definition ist sehr oberflächlich wenn. Haskell zum Beispiel, das ist eine Reine funktionale Sprache, implementiert viele weitere Konzepte wie Funktionen, Zusammensetzung, funktoren, currying, Monaden, etc.

Fazit

Eigentlich OOP und FP sind zwei verschiedene Konzepte, die nichts gemein haben, ich würde sogar sagen, dass es nichts zu vergleichen. Somit glaube ich, dass das, was Sie gelesen haben, von Underscore.js docs ist ein Missbrauch der Sprache.

Sollten Sie nicht studieren Programmier-Paradigmen, die in den Anwendungsbereich dieser Bibliothek. In der Tat, wie Sie code schreiben, der mit Underscore.js macht es ähnlich wie OOP und FP, aber es ist nur eine Frage der Erscheinung. Daher gibt es nichts wirklich spannendes unter der Haube 🙂

---

Siehe Wikipedia für vertiefte Lektüre.

• https://en.wikipedia.org/wiki/Programming_paradigm
• https://en.wikipedia.org/wiki/Object-oriented_programming
• https://en.wikipedia.org/wiki/Functional_programming

FP

In FP, eine Funktion übernimmt Eingaben und erzeugt eine Ausgabe, mit der Garantie, dass die gleichen Eingaben wird der Ertrag der gleichen Ausgänge. Um dies zu tun, eine Funktion muss immer der Parameter für die Werte, die das Unternehmen betreibt und nicht verlassen sich auf Staat. Dh, wenn eine Funktion stützt sich auf den Staat, und dass sich der Zustand ändert, die Ausgabe der Funktion könnte eine andere sein. FP vermeidet dies um jeden Preis.

Zeigen wir eine Mindest-Umsetzung der map im FP und OOP. In diesem FP-Beispiel unten, beachten Sie, wie map arbeitet nur auf lokalen Variablen und setzt nicht auf Staatliche

JS:

const _ = {
                 //? has two parameters
  map: function (arr, fn) {
      //? local
    if (arr.length === 0)
      return []
    else
            //? local               
                //? local           //? local    //? local
      return [ fn(arr[0]) ].concat(_.map(arr.slice(1), fn))
  }
}

const result =
  //? call _.map with two arguments
  _.map([1, 2, 3], function(n){ return n * 2; })


console.log(result)
//[ 2, 4, 6 ]

In diesem Stil, es spielt keine Rolle, dass map gespeichert wurde, in die _ Objekt - das macht es nicht "OOP", da ein Objekt verwendet wurde. Wir konnte gerade als leicht geschrieben -

JS:

function map (arr, fn) {
  if (arr.length === 0)
    return []
  else
    return [ fn(arr[0]) ].concat(map(arr.slice(1), fn))
}

const result =
  map([1, 2, 3], function(n){ return n * 2; })

console.log(result)
//[ 2, 4, 6 ]

Dies ist das Grundrezept für einen Anruf im FP -

//? function to call
             //? argument(s)
someFunction(arg1, arg2)

Die Bemerkenswerte Sache für FP ist hier, dass map hat zwei (2) Parameter arr und fn, und die Ausgabe von map richtet sich einzig und allein auf diese Eingänge. Sie werden sehen, wie diese änderungen sich dramatisch in die OOP-Beispiel unten.

---

OOP

In OOP-Objekte dienen zum speichern des Status. Wenn eine Methode eines Objekts aufgerufen wird, wird der Rahmen der Methode (Funktion) ist dynamisch an das empfangende Objekt als this. Da this ist ein ändern Wert, OOP kann nicht garantieren, jede Methode hat die gleiche Leistung, auch wenn der gleiche Eingang ist gegeben.

NB wie map nur dauert nur ein (1) argument unten fn. Wie können wir map mit nur einem fn? Was werden wir map? Wie kann ich festlegen, das Ziel zu map? FP hält dies für ein Alptraum, weil die Ausgabe der Funktion hängt nicht mehr ausschließlich auf die Eingänge - Jetzt die Ausgabe von map ist schwieriger zu bestimmen, denn es hängt von der dynamische Wert von this -

JS:

            //? constructor
function _ (value) {
         //? returns new object
  return new OOP(value)
}

function OOP (arr) {
  //? dynamic
  this.arr = arr
}
                           //? only one parameter
OOP.prototype.map = function (fn) {
     //? dynamic
  if (this.arr.length === 0)
    return []
  else         //? dynamic           //? dynamic
    return [ fn(this.arr[0]) ].concat(_(this.arr.slice(1)).map(fn))
}

const result =
  //? create object
             //? call method on created object
                    //? with one argument
  _([1, 2, 3]).map(function(n){ return n * 2; })


console.log(result)
//[ 2, 4, 6 ]

Dies ist das Grundrezept für einen dynamischen Aufruf in OOP -

//? state
       //? bind state to `this` in someAction
                  //? argument(s) to action
someObj.someAction(someArg)

---

FP revisited

In der ersten FP Beispiel sehen wir .concat und .slice - nicht OOP dynamische Aufrufe? Sie sind, aber diese nicht ändern, wird die Eingabe-array, und so sind Sie sicher für die Verwendung mit FP.

Sagte, die Mischung der Aufruf Stile können ein bisschen ein Dorn im Auge. OOP bevorzugt ein "infix" - notation, wo die Methoden (Funktionen) angezeigt werden zwischen die Argumente der Funktion -

//? arg1
     //? function
                       //? arg2
user .isAuthenticated (password)

Dies ist, wie JavaScript-Operatoren funktionieren auch -

//? arg1
   //? function
      //? arg2
   1  +  2

FP bevorzugt ein "Präfix" - notation, wo die Funktion kommt immer vor seinen Argumenten. In einer idealen Welt wären wir in der Lage zu call OOP-Methoden und-Operatoren in alle position, aber leider ist JS nicht funktionieren auf diese Weise -

//? invalid use of method
.isAuthenticated(user, password)

//? invalid use of operator
+(1,2)

Durch die Umwandlung Methoden wie .conat und .slice Funktionen, können wir schreiben FP-Programme auf eine mehr Natürliche Weise. Beachten Sie, wie konsequente Verwendung der Präfix-notation macht es einfacher, um sich vorzustellen, wie die Berechnung durchführt -

function map (arr, fn) {
  if (isEmpty(arr))
    return []
  else
    return concat(
      [ fn(first(arr)) ]
      , map(rest(arr, 1), fn)
    )
}

map([1, 2, 3], function(n){ return n * 2; })
//=> [ 2, 4, 6 ]

Die Methoden werden wie folgt umgewandelt -

function concat (a, b) {
  return a.concat(b)
}

function first (arr) {
  return arr[0]
}

function rest (arr) {
  return arr.slice(1)
}

function isEmpty (arr) {
  return arr.length === 0
}

Dieser beginnt zu zeigen, andere stärken der FP, wo Funktionen gehalten werden kleine und konzentrieren sich auf eine Aufgabe. Und weil diese Funktionen arbeiten nur auf Ihre Eingaben, können wir leicht die Wiederverwendung in anderen Bereichen unseres Programms.

Ihre Frage war ursprünglich gestellte 2016. Da die modernen JS-Funktionen ermöglichen Ihnen das schreiben von FP in eleganter Weise -

JS:

const None = Symbol()

function map ([ value = None, ...more ], fn) {
  if (value === None)
    return []
  else
    return [ fn(value), ...map(more, fn) ]
}

const result =
  map([1, 2, 3], function(n){ return n * 2; })

console.log(result)
//[ 2, 4, 6 ]

Einer weiteren Verfeinerung mit Ausdrücke statt Aussagen -

JS:

const None = Symbol()

const map = ([ value = None, ...more ], fn) =>
  value === None
    ? []
    : [ fn(value), ...map(more, fn) ]
    
const result =
  map([1, 2, 3], n => n * 2)

console.log(result)
//[ 2, 4, 6 ]

Aussagen beruhen auf Nebenwirkungen in der Erwägung, dass Ausdrücke geben direkt einen Wert ein. Ausdrücke lassen weniger potentielle "Löcher" in Ihrem code, wo Aussagen kann nichts tun jederzeit, wie auslösen eines Fehlers oder verlassen einer Funktion ohne Rückgabe eines Wertes.

---

FP mit Objekten

FP bedeutet nicht "nicht verwenden Objekte" - es geht um die Erhaltung der Fähigkeit, leicht Grund über Ihre Programme. Wir können das gleiche schreiben map Programm, das gibt die illusion, dass wir mit Hilfe der OOP, aber in Wirklichkeit verhält es sich eher wie FP. Es sieht wie eine Methode aufrufen, aber die Umsetzung stützt sich nur auf lokale Variablen und nicht auf dynamischen Zustand (this).

JavaScript ist eine reiche, expressive, multi-Paradigma Sprache, die es Ihnen ermöglicht, Programme zu schreiben, um Ihre Bedürfnisse und Vorlieben -

JS:

function _ (arr) {
  function map (fn) {
      //? local
    if (arr.length === 0)
      return []
    else
            //? local
                //? local         //? local      //? local
      return [ fn(arr[0]) ].concat(_(arr.slice(1)).map(fn))
  }
         //? an object!
  return { map: map }
}

const result =
            //? OOP? not quite!
  _([1, 2, 3]).map(function(n){ return n * 2; })

console.log(result)
//[ 2, 4, 6 ]