Quando hai imparato JS, qual è stato il tuo momento Aha? [chiuso]

Ti ricordi quando stavi imparando JavaScript? Qual è stato il momento in cui hai "capito" improvvisamente? (Ad esempio, il mio momento aha CSS è stato quando ho saputo del modello di scatola ...)

Il motivo per cui lo sto chiedendo è che sto imparando JS per 6 settimane, ma lo trovo ancora abbastanza confuso. Ecco una citazione da qualcosa che ho letto di recente su SO:

"... le funzioni si comportano in modo simile ai valori, in quanto il metodo è una proprietà dell'oggetto che ha un valore di una funzione (che è anche un oggetto)."

Sono curioso di sapere se anche tu eri confuso all'inizio e che cosa ti ha fatto capire.

(Sto leggendo i siti "Semplicemente JavaScript", il libro "Eloquent JavaScript" e seguendo il tutorial JavaScript essenziale di Lynda. Non ho alcuna esperienza di programmazione ed è stato terribile in matematica;)

Grazie!

Penso che il più grande momento "AHA" per me sia stato quando ho compreso appieno quanto segue:

I valori delle variabili possono essere qualsiasi cosa, comprese le funzioni

var person = {
    name: 'Sean',
    getName: function() { return this.name; },
    numbers: [7, 11, 41]
}

var myvar = person.name;
alert(myvar); //prints name
alert(myvar()); //"myvar" is not a function error
alert(myvar.length); //undefined

myvar = person.getName;
alert(myvar); //prints the contents of the function as a string
alert(myvar()); //calls the function
alert(myvar.length); //undefined

myvar = person.numbers;
alert(myvar); //prints contents of array
alert(myvar()); //"myvar" is not a function error
alert(myvar.length); //prints 3

Per me è stato quando ho capito che il contesto (quello che thisindica) di una funzione può essere cambiato arbitrariamente

http://www.digital-web.com/articles/scope_in_javascript/

Sono d'accordo con ciò che alcune delle altre risposte hanno toccato; Il momento degli A-ha per me è stato quando ho capito cosa fosse una chiusura .

Ho pubblicato una risposta alla domanda Cos'è una chiusura? per spiegare questo.

Senza comprendere le chiusure, Javascript è un linguaggio piuttosto limitato, con alcune belle funzioni di sintassi abbreviate come []per array e JSON ( {}per oggetti) e nel contesto del browser, il DOM ( window/ document).

Tuttavia, una volta comprese le chiusure, si ottiene molta comprensione :

• Che cos'è veramente un prototipo ( vedi qui )
• Perché i prototipi sono la chiave per OOP in Javascript ( vedi qui )
• Come la maggior parte dei gestori di eventi in Javascript davvero il lavoro (può sembrare come magia senza capire chiusure)
• Come risparmiare un sacco di codice (e / o tempo) con i callback

risorse

• Non ho visitato l'intero sito ma sembra un'ottima risorsa, toccando questi argomenti: http://eloquentjavascript.net/contents.html
• Dai un'occhiata a http://ejohn.org/apps/learn/ per un ottimo tutorial su Javascript

Penso che il linguaggio più essenziale 'Aha per me in Javascript fosse

• Funziona come oggetti
• chiusure
• Orientamento agli oggetti basato sul prototipo
• Scoping in JavaScript

Per tutti questi argomenti, dovresti trovare molte risorse sul web.

(E non pensare che tutto diventerà totalmente logico: JavaScript è confuso)

javascript è stato difficile per me quando ho iniziato a impararlo alcuni anni fa perché ho iniziato a imparare lo sviluppo web dall'estremità delle cose sul lato server (php e perl).

Non era tanto la sintassi o OOP o qualcosa che mi sfuggiva, più la vita e la propensione agli eventi di javascript - andando da "fai questo e questo e questo e servilo e hai finito" e "fai" e questo e questo e poi siamo in costante stato di attesa affinché qualcosa accada e risponda fino a quando l'utente lascia la pagina ". Questo mi ha davvero colpito.

Non credo di poter nominare qualcosa in particolare che lo abbia davvero fatto sprofondare (nessun momento "aha!" Definitivo - se dovessi nominare un momento specifico, direi quando stavo imparando AJAX per uno script di suggerimenti di ricerca, ma l'IMO è semplicemente arbitrario) ma quando alla fine ho capito la differenza, tutto è diventato molto più semplice da lì :)

Quando finalmente ho capito l'idea di poter ridefinire qualsiasi parte della lingua in qualunque schifo lo voglio. A questo proposito, è ancora più potente di C. Ad esempio, se non mi piace la toString()funzione standard , implementerò la mia:

x.toString = function () {
    return "this is MY toString function biatch!";
}

Quando ho capito che potevi impostare una proprietà su un oggetto funzione.

Anche quando ho finalmente capito quale fosse il prototipo.

function Alpha(){
    return 'aplha';
}
Alpha.Beta = function(){
    return 'beta';
}
Alpha.prototype.Delta = function(){
    return 'delta';
}

Alpha(); // 'alpha'
Alpha.Beta(); // 'beta'
new Alpha().Delta(); // 'delta'

function Obj() {
    this.x = 42;
    this.value = function() {
        return this.x;
    };
}

var o = new Obj();
o.value();        // 42
var f = o.value;
f();              // undefined??

E il momento degli a-ha quando finalmente cogli questi risultati.

Aha moment # 1, per me: rendersi conto che JavaScript, il linguaggio, è distinto dal suo uso principale: HTML dinamico e programmazione web lato client. Sarei frustrato con JavaScript, quando ero davvero frustrato con le incompatibilità DOM e browser.

Aha moment # 2: Comprendere che l'eredità può essere eseguita in molti modi. L'eredità tipica basata sulla classe è solo una. Ce ne sono altri, ovvero basati sul prototipo (lo stile utilizzato in JavaScript).

Per quanto riguarda il n. 1, non posso resistere a raccomandare JavaScript: le parti buone . Tratta JavaScript come un linguaggio a tutti gli effetti.

Nessun blocco dei blocchi e sollevamento.

foo(); // function executes, no error

if (...) {
  function foo(){
    ...
  }
}

È solo Schema con sintassi.

Quello era quello grande per me.

jQuery è stato sostanzialmente il momento "a-ha" per me. La sintassi sembrava familiare dopo avere molta esperienza con la sintassi LINQ / lambda in C #.