JavaScript è morto. Long Live JavaScript!

Per 16 anni, JavaScript è il linguaggio del browser web. Questo linguaggio ha permesso la costruzione di applicazioni web convincenti e hanno contribuito al successo del web. Altri linguaggi di scripting potrebbe avere riempito il ruolo JavaScript JavaScript è stato, ma non nel posto giusto al momento giusto. Microsoft ha aggiunto a Internet Explorer di base molto tempo fa, ma il linguaggio JavaScript è stato in tutti i browser e così ha vinto. Dal momento che JavaScript è stato cross-browser e almeno abbastanza buono, i produttori dei browser non hanno avuto bisogno di aggiungere altri interpreti di lingua per gli stessi browser.

Ma ancora non ha scelto di utilizzare JavaScript. E 'stata la sola opzione.Ha caratteristiche potenti come le chiusure e abbiamo imparato ad amare queste caratteristiche, mentre chiudono un occhio alle parti verrucosa della lingua. C'è stato anche un sacco di scuse alla comunità dei programmatori sulla falsariga di "Sì, sappiamo che è una lingua piuttosto funky, ma si prega di dare una possibilità. Sono sicuro che imparerai ad amarlo. "Non dovrebbe essere difficile vendere la qualità del linguaggio. JavaScript è stato descritto come un esperimento sfuggito al laboratorio un po 'troppo presto e siamo stati bloccati con le verruche da allora.

Eppure, JavaScript è stato un grande linguaggio. Nel 2007, Steve Yegge dichiarato JavaScript come Il linguaggio Next Big ed è stato. Tra ieri e oggi basate su JavaScript applicazioni web sono diventate più grandi e migliori.Con l'aiuto di JavaScript, il web ha continuato a prosperare anche con la minaccia di natale applicazioni mobili presa in consegna lo stesso spazio.

In tempi molto recenti, JavaScript ha fatto il suo tentativo più riuscito ad essere un linguaggio server-side. La piattaforma Node.js, con la sua non-blocking I / O, può essere la soluzione di un problema che i programmatori hanno bisogno di risolvere da molto tempo. JavaScript è il linguaggio per Node.js JavaScript e così può andare avanti per il giro di diventare un successo linguaggio server-side, dopo molti tentativi falliti in passato.

Nel complesso, JavaScript è stato un successo selvaggio. Il linguaggio di programmazione più popolari al mondo. Ma se il browser è morto oggi, quanto il nuovo codice JavaScript sarebbe stato scritto domani? JavaScript molto probabilmente sarebbe diventato un linguaggio frangia durante la notte. Ma il browser non è morire domani. Saremo di programmazione per gli anni a venire.

Come JavaScript è stato usato per programmi più e più grandi, le verruche del linguaggio sono diventati più evidenti e causato crescente quantità di dolore per molti sviluppatori. Può essere una sorpresa che anche se ho scritto su JavaScript per anni, io non sono un fanboy JavaScript. La maggior parte dei miei articoli JavaScript sono state lavorando su di me attraverso le difficoltà di trovare una coesistenza pacifica con la lingua. Sì, ho goduto di programmazione in JavaScript e ho imparato molto, ma certamente ci sono state volte in cui mi sono sentito come se fossi sguazzare nel fango.

Una delle carenze più evidenti in JavaScript è con la sua interfaccia utente: la sua sintassi. L'incapacità di migliorare rapidamente la sua sintassi ha portato alla caduta della lingua.

Il caso per le estensioni di sintassi: Idioms Verbose

Qui guardiamo solo quattro dei tanti esempi in cui la sintassi di JavaScript può essere migliorato per rimuovere idiomi verbose dalle nostre esistenze programmazione giornaliera.

Parametri opzionali e valori predefiniti

Funzioni JavaScript può essere chiamato con un numero variabile di parametri attuali. Questo rende alcuni dei parametri formali nella dichiarazione opzionale della funzione. Spesso questi parametri opzionali deve essere impostato su un valore predefinito se nessun parametro effettivo viene fornito. Sono pronto a scommettere che hai scritto e visto un sacco di codice come il seguente.

funzione (a, b, opzione) {
    option = opzione | | {};
    / / ...
}

Ho ancora e scrivere il codice come questo. Questo codice è sbagliato. Se un valore falsy è passato alla funzione per opzione poi la cosa sbagliata succede. Dovremmo scrivere quanto segue.

funzione (a, b, opzione) {
    option = arguments.length> 2? opzione: {};
    / / ...
}

Anche se questo codice esprime il pensiero inteso di impostare un valore predefinito se un parametro attuale per l'opzione non viene fornita, è troppo prolisso e meno leggibile. Il lettore deve contare per determinare quale variabile ha indice 2. Al di là del disagio, la versione corretta è più difficile da mantenere. E 'facile produrre il seguente codice buggy se il bparametro viene rimosso.

funzione (a, opzione) {
    option = arguments.length> 2? opzione: {};
    / / ...
}

Se l'applicazione utilizza i parametri opzionali con valori di default, qualche nuova sintassi sarebbe vantaggioso per voi.

funzione (a, b, opzione = {}) {
    / / ...
}

L'aggiunta di questa musica nuova sintassi del linguaggio meglio alle esigenze dell'applicazione.

Lasciare

Il codice seguente buggy sembra familiare?

for (var i = 0, Ilen = elements.length; i <Ilen; i + +) {
    var elemento = elementi [i];
    LIB_addEventListener (elemento, 'click', function (evento) {
        alert ('Sono stato in origine il numero' + i);
    });
}

Tutti gli elementi sono stati lo stesso numero?! La soluzione è usare una espressione funzione immediatamente valutato in modo che ogni avviso riporta un numero diverso. Questo è l'idioma "let", dopo vari Lisplasciare forme.

for (var i = 0, Ilen = elements.length; i <Ilen; i + +) {
    var elemento = elementi [i];
    (Function (num) {
        LIB_addEventListener (elemento, 'click', function (evento) {
            alert ('Sono stato in origine il numero' + num);
        });
    } (I));
}

Certo a volte ascoltatori delegato potrebbe essere migliore di codice di cui sopra ma a volte il codice qui sopra è l'idea desiderata. Nel caso di cui sopra, stiamo cercando di legare l'ordine degli elementi, quando il ciclo viene eseguito. Questo ordine può essere perduto con il modello di delega, se gli elementi sono riorganizzate nel DOM.

Questa sintassi è particolarmente scomoda a causa della distanza tra il formale numero e reale i parametri della funzione immediata.

La funzione immediata potrebbe essere preso in considerazione in un'altra posizione e chiamata all'interno del ciclo.

funzione attachListener (elemento, num) {
    LIB_addEventListener (elemento, 'click', function (evento) {
        alert ('Sono stato in origine il numero' + num);
    });
}
for (var i = 0, Ilen = elements.length; i <Ilen; i + +) {
    attachListener (elementi [i], i);
}

Anche con questa opzione, a volte i programmatori usano ancora la funzione immediato perché trasmette meglio il loro messaggio destinato ai lettori.

Se l'applicazione utilizza l'idioma lasciato, non sarebbe bello avere la nuova sintassi per questo?

for (var i = 0, Ilen = elements.length; i <Ilen; i + +) {
    var elemento = elementi [i];
    sia (num = i) {
        LIB_addEventListener (elemento, funzione (event) {
            alert ('Sono stato in origine il numero' + num);
        });
    };
}

Con num e ho insieme è molto più facile da leggere questo codice e un nuovo ambito che contiene nuove è stato introdotto così la chiusura funziona correttamente. Ancora una volta, l'aggiunta di nuova sintassi può sintonizzare meglio la lingua alle esigenze dell'applicazione.

Moduli

Uno dei linguaggi più comuni programmi JavaScript che tutti noi conosciamo e amiamo è di solito chiamato "il modello di modulo." Questo linguaggio offre i vantaggi di variabili incapsulati che sono private al modulo e conferisce sanità mentale al nostro codice.

var evento = (function () {

    / / Variabili private
    ascoltatori var = [];
   
    funzione addEventListener (f) {
        listeners.push (f);
    }

    clearEventListeners function () {
        ascoltatori = [];
    }
    
    / / ...
    
    / / Esportazione API del modulo
    ritorno {
        addEventListener: addEventListener,
        clearEventListeners: clearEventListeners
        / / ...
    };
}());

L'obiettivo di incapsulamento qui non è la sicurezza. E 'far sì che altri sviluppatori mantenere i loro sporchi, la scimmia-patching mani fuori i dati del modulo.

L'esportazione può essere fatta alcuni modi, ma non importa in che modo vi è una certa piastra caldaia.

L'importazione è inoltre verbose

(Function () {

    / / Importazione proprietà desiderate del modulo evento
    var = addEventListener event.addEventListener;
    clearEventListeners var = event.clearEventListeners;
    
    / / ...
}());

Alcuni nuova sintassi sarebbe bello per trasmettere l'intento del pattern modulo migliore.

Modulo evento {
    
    / / Variabili private
    ascoltatori var = [];
   
    esportazione addEventListener funzione (f) {
        listeners.push (f);
    }

    esportazione clearEventListeners function () {
        ascoltatori = [];
    }
    
    / / ...
}

(Function () {

    importazione evento;
    
    / / ...
}());

Il modello di modulo è un po 'ovunque e qualche nuova sintassi per esprimere al meglio questo idioma sarebbe meglio sintonizzare il linguaggio di tutte le nostre applicazioni.

Eredità

Questi esempi sono stati idioma cresce nel modo in cui ogni campata un crescente numero di righe di codice. Il linguaggio JavaScript che si estende potenzialmente il più linee del vostro programma può essere l'idioma eredità.

funzione di dipendenti (primo, ultimo, posizione) {
    / / Chiama il costruttore della superclasse
    Person.call (questo, primo, ultimo);
    this.position = posizione;
};
/ / Eredita da Persona
Employee.prototype = Object.create (Person.prototype);
Employee.prototype.constructor dipendenti =;

/ / Definire un overridding toString () metodo
Employee.prototype.toString = function () {
    / / Chiama toString sovrapposto di una superclasse () del metodo
    ritorno Person.prototype.toString.call (questo) +
           'È un' this.position +;
};

Che confusione. Sì JavaScript rende l'ereditarietà singola così possibile, collegando prototipi, ma ci vuole un sacco di codice per fare le cose manualmente Super accadere che modo ti avrebbe fatto piacere eredità al lavoro.

Se ci potrebbe essere un incubo per la manutenzione che è. Le stringhe "Persona" e "dipendenti" sono disteso in tutto il codice per la "classe" dei dipendenti.

Se le classi con ereditarietà sono una grande parte della vostra applicazione, alcune sintassi sarebbe davvero aiutare a pulire il codice.Forse qualcosa di simile alla seguente.

Impiegato classe estende Person {
    costruttore (primo, ultimo, posizione) {
        super (primo, ultimo);
        posizione pubblica = posizione;
    }
 
    aggiornamento (fotocamera) {
        ritorno super.update () + 'è una' posizione +;
    }
}

Questo è un miglioramento importante.

Imparare dai Idiomi

Questi idiomi comuni chiarire che JavaScript potrebbe usare qualche nuova sintassi per diverse ragioni. La capacità di fare quello che vogliamo è di solito in JavaScript da qualche parte. La verbosità degli idiomi è a volte troppo. Abbiamo tagliato gli angoli. A volte evitiamo di alcuni algoritmi, perché gli idiomi sono troppo prolisso. Gli idiomi non si spiegano. Si tratta di segreti all'interno della comunità e l'intento non è facilmente riconoscibile da parte di estranei.

Il comitato ECMAScript ha riconosciuto che gli idiomi di cui sopra, e altri idiomi, sono comuni attraverso una vasta gamma di applicazioni. Ci sono proposte per tutti questi casi la sintassi in Armonia. Alcuni di loro possono riuscire ad entrare nella prossima versione di ECMAScript e nel browser per il vostro uso. Se la nuova sintassi arriva alla fine è possibile utilizzare usarlo.

Idiomi potrebbe essere emerso a vostra applicazione che non appaiono in una vasta gamma di applicazioni. Per esempio, Node.js 's non-blocking I / O e la forte relazione callback senza dubbio portare a idiomi che non compaiono negli script del browser. Sintassi specifica per le applicazioni solo non sarà mai probabilmente lo fanno in ECMAScript.

Se si desidera utilizzare la sintassi specializzata per gli idiomi generali come quelle mostrate in precedenza o se volete la sintassi per la vostra idiomi propri, cosa si può fare?

Se solo avessimo macro

Linguaggi Lisp hanno avuto conclamata macro per decenni. Attraverso le macro, Lisp offre ai programmatori la possibilità di regolare la sintassi del linguaggio per soddisfare al meglio le loro applicazioni. A causa della sua macro, Lisp è stato descritto come "il linguaggio di programmazione programmabile." Roba potente.

Lisp s-espressione sintassi, si sa, la sintassi con tutte quelle parentesi, dà il linguaggio una proprietà speciale chiamato homoiconicity. Vuol dire circa la sintassi del linguaggio è anche la sintassi delle sue strutture dati o che albero sintattico di un programma utilizza i dati lingue strutture. Questo rende homoiconicity Lisp macro possibile.

Corso Java - Corsi Java - Corsi programmazione Java

 Corso programmazione Android - Certificazione Android