Quale lingua ha introdotto l'idea di variabili private (nascoste)? [duplicare]

Una forma di incapsulamento Javascript è quella di ambito . Non ci sono moduli come tali - le persone si limitano a inserire cose all'interno di una funzione ( (function(){ ... })(this) ) e le cose all'interno di quella funzione non possono essere utilizzate all'esterno. Puoi nasconderne un po 'in ambito locale, e molti linguaggi l'hanno avuto (anche se probabilmente, senza le funzioni di prima classe questo non è sufficiente per incapsulamento di dati).

Una volta che iniziamo a menzionare funzioni e cronologia di prima classe, cadiamo fermamente nel parlare di Lisp. E c'è anche molto da dire.

Early Fortran (per il 704) non aveva subroutine o scope. Era Fortran II che ha introdotto queste cose .

Mi scuso per aver scritto Lisp (1958) con una sola frase ... e senza dire molto su Fortran (1957), o Fortran II (1958). Lisp ha avuto chiusure e Fortran II sembra avere qualche scope lessicale ...

Quando parli di incapsulamento e programmazione strutturata il nome che dovrebbe saltarti addosso è Niklaus Wirth .

Ciò che pensiamo spesso come incapsulamento sono cose come variabili private all'interno di un modulo. Certo, c'erano cose che potevano entrare e uscire dall'ambito che non potevano essere accessibili al di fuori dell'ambito. Ma non avevi "qui c'è questo modulo di codice che ha alcune cose che non puoi vedere da quelle parti".

Era Modula 2 (1978) che ci ha portato la sintassi come:

DEFINITION MODULE M1;
  EXPORT QUALIFIED a, b, c, P;

Dove si potrebbe successivamente accedere a M1.a e M1.b ma non a M1.d (perché non è stato esportato).

Potresti anche fare:

MODULE M2;
  FROM M1 IMPORT a, P;

Alcuni linguaggi sembrano decisamente Pythonish ...

MODULE Hello;
FROM STextIO IMPORT WriteString;
BEGIN
  WriteString("Hello World!");
END Hello.

Questo è qualcosa di più che nascondere qualcosa che non rientra nello spazio dei nomi clobber. Ciò sta nascondendo la visibilità di alcune variabili, procedure o funzioni da altri moduli. ( Esercitazione su moduli all'interno di Modula-2 ) Questo tipo di incapsulamento è ciò a cui spesso pensiamo ora e vediamo nelle lingue come C ++ (1983), Java (1995) e C # (2000).

Modula non era l'unica lingua per nascondere una qualche forma di dati. Simula era un linguaggio precoce orientato agli oggetti che aveva alcuni incapsulamenti di dati:

Questaparticolareestensioneeradaun'estensionesuccessivaallalinguada intorno al 1972 . Questo si è fatto strada nello standard di Simula 87 (l'originale Simula 67 aveva tutto come pubblico e mancava l'incapsulamento ). Questo linguaggio ha una strong influenza su C ++ ( Conversazione con Bjarne Stroustrup , Perché ho creato C ++ ).

Questo blocco di protezione per un identificatore consentiva a una classe di specificare se le sue sottoclassi - Hidden potevano essere utilizzate solo nella classe in cui la sua dichiarata e Protected potevano essere utilizzate solo dove era dichiarata e le sue sottoclassi.

Un'altra menzione da un altro linguaggio orientato agli oggetti vecchi - Smalltalk (1972).

In Smalltalk, tutte le variabili di istanza erano protette (visibili solo alla classe e alle sue sottoclassi) e tutti i metodi erano pubblici ( Modello oggetto Smalltalk ). Questo potrebbe essere usato per preformare qualche incapsulamento.

È stata considerata una cattiva forma accedere a una variabile di istanza della superclasse da una sottoclasse o a invocare un metodo nel 'privato' categoria ).

Lettura correlata:

• Cronologia dei modificatori del controllo di accesso come pubblica / privata / protetta

L'idea di Local Scope risale agli anni '50. Fortran ce l'ha, Lisp ce l'ha.

Vedi Ambito (Informatica) .

Come ha detto l'altro, le variabili locali tornano a FORTRAN.

Le basi per ciò che ora chiamiamo "programmazione orientata agli oggetti", in particolare classi con metodi e variabili di istanze pubbliche e private, sono state stabilite in Simula 67 da Ole-Johan Dahl. Ha scritto un bel po 'di cose nella sua sezione di "Programmazione strutturata" [Dahl, Dijkstra & Hoare]. (No, NON PUOI prendere in prestito la mia copia!)

Se parli di incapsulamento come usato nei moderni linguaggi OO, le specifiche linguistiche più chiare e più antiche si trovano in Simula-67. Tutte le funzionalità chiave di OO sono presenti e la lingua è stata ampiamente utilizzata all'interno di una specifica comunità.

Se parli di incapsulamento come equivalente all'oscilloscopio, le specifiche del linguaggio più chiare e più precoci sono Algol 58 (aka IAL). La specifica di Algol 60 è stata ampiamente implementata e contiene i concetti di ambito di funzione e ambito di blocco che ora si trovano in tutti i linguaggi di tipo C.

Intorno alla stessa ora FORTRAN aveva variabili locali per le subroutine e COMMON condiviso ma non per ambito di blocco.

Inoltre nello stesso periodo Lisp offriva un ambito dinamico e una sorta di chiusura ma non di ambito lessicale o incapsulamento come ora lo capiamo.