Al aprender JS, ¿cuál fue tu momento Aha? [cerrado]

¿Recuerdas cuando estabas aprendiendo JavaScript? ¿Cuál fue el momento en que de repente lo "entendiste"? (Por ejemplo, mi momento aha de CSS fue cuando aprendí sobre el modelo de caja ...)

La razón por la que pregunto es que estoy aprendiendo JS durante 6 semanas, pero todavía lo encuentro bastante confuso. Aquí hay una cita de algo que leí recientemente en SO:

"... las funciones actúan de manera similar a los valores, ya que el método es una propiedad del objeto que tiene el valor de una función (que también es un objeto)".

Tengo curiosidad por saber si también estabas confundido al principio y qué fue lo que te hizo entenderlo.

(Estoy leyendo los puntos del sitio "Simplemente JavaScript", el libro "JavaScript elocuente" y siguiendo el tutorial de JavaScript esencial de Lynda. No tengo experiencia en programación y era terrible en matemáticas;)

¡Gracias!

Creo que el momento más grande de "AHA" para mí fue cuando comprendí completamente lo siguiente:

Los valores variables pueden ser cualquier cosa, incluidas las funciones

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

Para mí fue cuando entendí que el contexto (lo que thisseñala) de una función se puede cambiar arbitrariamente

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

Estoy de acuerdo con lo que algunas de las otras respuestas han tocado; El momento A-ha para mí fue cuando entendí lo que era un cierre .

Publiqué una respuesta a la pregunta ¿Qué es un cierre? para ayudar a explicar esto.

Sin comprender los cierres, Javascript es un lenguaje bastante limitado, con algunas características agradables de sintaxis abreviada como []para matrices y JSON ( {}para objetos), y en el contexto del navegador, el DOM ( window/ document).

Sin embargo, una vez que entiendes los cierres, mucha comprensión entra en juego :

• Qué es realmente un prototipo ( ver aquí )
• ¿Por qué los prototipos son la clave para OOP en Javascript? ( Ver aquí )
• Cómo funcionan realmente la mayoría de los controladores de eventos en Javascript (puede parecer mágico sin comprender los cierres)
• Cómo ahorrar mucho código (y / o tiempo) con devoluciones de llamada

Recursos

• No he visitado todo este sitio, pero parece un gran recurso, tocando estos temas: http://eloquentjavascript.net/contents.html
• Visite http://ejohn.org/apps/learn/ para obtener un excelente tutorial sobre Javascript

Creo que el lenguaje más esencial 'Ajá para mí en Javascript era

• Funciona como objetos.
• Cierres
• Orientación a objetos basada en prototipos
• Alcance en JavaScript

Para todos estos temas, debe encontrar muchos recursos en la web.

(Y no piense que todo se volverá totalmente lógico: JavaScript es confuso)

javascript fue difícil para mí cuando comencé a aprenderlo hace algunos años porque comencé a aprender desarrollo web desde el lado del servidor (php y perl).

No fue tanto la sintaxis o la OOP o cualquier cosa que me eludió, más aún la vida y el desarrollo de eventos de javascript, pasando de "hacer esto y esto y esto y servirlo y listo" para "hacer esto y esto y esto y luego estamos en un estado constante de esperar que algo suceda y responder hasta que el usuario abandone la página ". Eso realmente me dejó sin aliento.

No creo que pueda nombrar nada en particular que realmente lo haya hundido (ningún momento definitivo "¡ajá!" - si tuviera que nombrar un momento específico, diría que cuando estaba aprendiendo AJAX para un script de sugerencia de búsqueda, pero en mi opinión eso es arbitrario), pero cuando finalmente comprendí la diferencia, todo se volvió mucho más fácil a partir de ahí :)

Cuando finalmente entendí la idea de que puedo redefinir cualquier parte del lenguaje a la basura que quiera. A este respecto, es aún más poderoso que C. Por ejemplo, si no me gusta la toString()función estándar , implementaré la mía propia:

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

Cuando me di cuenta de que podía establecer una propiedad en un objeto de función.

También cuando finalmente entendí cuál era el 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??

Y el momento a-ha cuando finalmente captas estos resultados.

Aha momento # 1, para mí: darse cuenta de que JavaScript, el lenguaje, es distinto de su uso principal: HTML dinámico y programación web del lado del cliente. Me sentiría frustrado con JavaScript, cuando realmente estaba frustrado con el DOM y las incompatibilidades del navegador.

Aha momento # 2: Comprender que la herencia se puede ejecutar de muchas maneras. La herencia típica basada en clases es solo una. Hay otros, a saber, basados ​​en prototipos (el estilo utilizado en JavaScript).

Con respecto al n. ° 1, no puedo resistirme a recomendar JavaScript: The Good Parts . Trata JavaScript como un buen lenguaje por derecho propio.

Sin bloque de alcance y elevación.

foo(); // function executes, no error

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

Es solo Scheme con sintaxis.

Ese fue el grande para mí.

jQuery fue básicamente el momento 'a-ha' para mí. La sintaxis se sintió familiar después de tener mucha experiencia con la sintaxis LINQ / lambda en C #.