Javascript è un linguaggio di programmazione funzionale?

Solo perché le funzioni sono oggetti di prima classe, ci sono chiusure e funzioni di ordine superiore, Javascript merita di essere chiamato un linguaggio di programmazione funzionale? La cosa principale che penso manchi sono le Pure Functions, e non "sembra" come altri linguaggi funzionali, come lisp (anche se non è proprio una buona ragione per non essere un linguaggio funzionale ...)

Ripetendo la mia risposta a una domanda simile,

Non esiste una definizione accettata di linguaggio di programmazione funzionale.

Se definisci il linguaggio funzionale come il linguaggio che supporta le funzioni di prima classe e lambdas, sì, JavaScript * è * un linguaggio funzionale.

Se si considerano anche fattori come il supporto per l'immutabilità, i tipi di dati algebrici, la corrispondenza dei modelli, l'applicazione parziale ecc., Allora JavaScript * non è * un linguaggio funzionale.

---

Ti incoraggio a leggere i seguenti post di blog correlati (e anche i commenti sottostanti):

• Scala non è un linguaggio funzionale

• Erlang non è funzionale

• Discussione di Reddit su "Erlang non è funzionale"

Direi che è un linguaggio multi-paradigma.

EDIT: è multi-paradigma e include costrutti funzionali.

se allunghi e distorci il termine "programmazione funzionale" fino al punto di discussioni filosofiche, questa domanda potrebbe essere di nuovo aperta. Tuttavia, ti ritrovi al livello di domande utili come "Il C ++ è davvero un linguaggio di programmazione"?

La risposta alla tua domanda a un livello più quotidiano è "no" .

La programmazione funzionale significa che il programma è concettualizzato come una valutazione di una funzione, piuttosto che un flusso di controllo. Il codice è una descrizione delle funzioni e non ha un concetto intrinseco di un flusso di controllo.

JavaScript ha un flusso di controllo ed è concettualizzato come linguaggio imperativo. Dal suo obiettivo progettuale, chiaramente non è un linguaggio funzionale.

Il termine linguaggio di "programmazione funzionale" è così sovraccarico in questi giorni che è quasi inutile. Esistono due significati dominanti:

1. Ha funzioni di prima classe
   • Javascript è questo!
2. Si basa sulle funzioni utilizzate nel calcolo lambda, con enfasi sull'evitare lo stato mutabile persistente (spesso sostituendolo con parametri passati alle funzioni)
   • Come comunemente scritto, Javascript non è da remoto questo!

Scegli il tuo significato e quindi la domanda è responsabile.

Non credo che ci sia una definizione concreta di programmazione funzionale, tuttavia molte cose che la gente considera "programmazione funzionale" possono essere fatte con javascript. Ecco un breve esempio in questo articolo.

Per me, Javascript è sia un linguaggio imperativo che un linguaggio funzionale, e puoi scegliere di usarlo in entrambi i modi e persino ( egad ) in entrambi i modi. Oppure puoi scegliere di usare un paradigma e non toccare mai l'altro. Tocca a voi. Come te, non penso che Javascript debba essere chiamato un linguaggio funzionale, perché ti permette di vagare dentro e fuori dal paradigma della programmazione funzionale. Forse se avesse un pragma di qualche tipo, per limitarti usando solo paradigmi di programmazione funzionale, sarebbe utile, penso. Ma, in sintesi, dico che è più un linguaggio imperativo / procedurale con alcune funzioni di programmazione funzionale integrate.

Tendo a non pensare ai linguaggi di programmazione come ad avere un paradigma particolare, ma che si prestano a determinati paradigmi. Tuttavia, solo perché si prestano a un particolare paradigma non significa che devi usare quel paradigma. È del tutto possibile scrivere programmi orientati agli oggetti in C e scrivere programmi imperativi in ​​ML. Non usare un certo paradigma per risolvere un problema perché il linguaggio non è progettato per esso sta solo limitando artificialmente te stesso (ovviamente dovresti comunque tenere conto dei limiti di un linguaggio quando decidi se una particolare soluzione sarà una buona soluzione).

Beh, non direi che è la programmazione funzionale, ma poi mi sarebbe dire che è orientato agli oggetti e proprio oggi un amico ha detto che non avrebbe messo su quello scaffale sia.

Quindi, anche se non direi che lo sia, credo che ci sia spazio per l'opinione. Ha le caratteristiche classiche della programmazione funzionale, non ne ha altre.

Javascript è a un certo punto. Dipende davvero da come procedi per programmarlo. Se codifico in modo OO, non sarebbe OO? Quindi, se semplicemente codifichi le cose in modo "funzionale", sarebbe funzionale. Immagino che sia un linguaggio multi-paradigma, quindi chiamarlo solo una cosa non è del tutto esatto.

@petraszd Riscrivo un po 'il tuo codice per ottenere un "nuovo" per l' operatore:

   
   function ffor(a, b, f){
     function it(i){
       if(i > b)return
       f(i)
       it(i+1)
     }
     it(a)
   }

   print("----" + new Date()+"----")

   var funcs = []
   ffor(0, 9, function(i){
     funcs.push(function(){return i})
   })

   ffor(0, 9, function(i){
     print(funcs[i]())
   })

Ma so che in questo modo ha degli svantaggi per i grandi loop ...

Domanda correlata sull'ottimizzazione della ricorsione della coda in JS

PS Pubblicato qui perché hanno problemi con la formattazione del codice durante la pubblicazione come commento

In Javascript, puoi fare qualcosa del genere !!

// Data
var fruits = [
    { name: 'apple',  price: 5 }, 
    { name: 'orange', price: 10 }, 
    { name: 'lemon',  price: 15 }
]

// Request Data from magicURL
request('magicURL')
    .then(selectKeyOf('price'))
    .then(priceMethod('sum'))
    .then((result)=>{
        console.log(result) // 30
    })

Ho creato una pagina github per dimostrare questo concetto e puoi clonare / visualizzare la mia implementazione

Come sappiamo, il linguaggio di programmazione funzionale non consente di modificare o mutare gli elementi (stato) delle funzioni, ma in javascript è consentito in tal senso che non è un linguaggio di programmazione funzionale, sebbene tratti la funzione come cittadini di prima classe.

Quello che odio davvero in JavaScript (se provi a vederlo come linguaggio FP) è questo:

function getTenFunctionsBad() {
  var result = [];
  for (var i = 0; i < 10; ++i) {
    result.push(function () {
      return i;
    });
  }
  return result;
}

function getTenFunctions() {
  var result = [];
  for (var i = 0; i < 10; ++i) {
    result.push((function (i) {
      return function () {
        return i;
      }
    })(i));
  }
  return result;
}

var functionsBad = getTenFunctionsBad();
var functions = getTenFunctions()
for (var i = 0; i < 10; ++i) {
  // using rhino print
  print(functionsBad[i]() + ', ' + functions[i]());
}

// Output:
//   10, 0
//   10, 1
//   10, 2
//   10, 3
//   10, 4
//   10, 5
//   10, 6
//   10, 7
//   10, 8
//   10, 9

Devi capire l'ambiente dello stack JS (non lo so se è il termine giusto) per capire un simile comportamento.

Nello schema, ad esempio, non puoi semplicemente produrre una cosa del genere (Ok, ok - con l'aiuto dei riferimenti delle lingue sottostanti puoi farlo):

(define (make-ten-functions)
  (define (iter i)
    (cond ((> i 9) '())
          (else (cons (lambda () i) (iter (+ i 1))))))
  (iter 0))

(for-each (lambda (f)
            (display (f))
            (newline)) (make-ten-functions))