Lors de l'apprentissage de JS, quel a été votre moment Aha? [fermé]

Vous souvenez-vous quand vous appreniez JavaScript? À quel moment avez-vous soudainement "compris"? (Par exemple, mon moment CSS aha a été quand j'ai découvert le modèle de boîte ...)

La raison pour laquelle je demande, c'est que j'apprends JS pendant 6 semaines, mais je trouve cela assez déroutant. Voici une citation de quelque chose que j'ai lu récemment sur SO:

"..les fonctions agissent de manière similaire aux valeurs, car la méthode est une propriété de l'objet qui a la valeur d'une fonction (qui est également un objet)."

Je suis curieux de savoir si vous étiez aussi confus au début et qu'est-ce qui vous a fait comprendre.

(Je lis les Sitepoints "Simply JavaScript", le livre "Eloquent JavaScript" et le didacticiel JavaScript de Lynda. Je n'ai aucune expérience en programmation et j'ai été horrible en mathématiques;)

Merci!

Je pense que le plus grand moment "AHA" pour moi a été quand j'ai bien compris ce qui suit:

Les valeurs variables peuvent être n'importe quoi, y compris les fonctions

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

Pour moi, c'est quand j'ai compris que le contexte (ce qui thispointe) d'une fonction peut être changé arbitrairement

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

Je suis d'accord avec ce que certaines des autres réponses ont touché; Le moment A-ha pour moi, c'est quand j'ai compris ce qu'était une fermeture .

J'ai posté une réponse à la question Qu'est-ce qu'une fermeture? pour aider à expliquer cela.

Sans comprendre les fermetures, Javascript est un langage assez limité, avec quelques belles fonctionnalités de syntaxe abrégée comme []pour les tableaux et JSON ({} pour les objets), et dans le contexte du navigateur, le DOM ( window/ document).

Cependant, une fois que vous comprenez les fermetures, beaucoup de compréhension se met en place :

• Quel prototype vraiment ( voir ici )
• Pourquoi les prototypes sont la clé de la POO en Javascript ( voir ici )
• Comment la plupart des gestionnaires d'événements en Javascript vraiment le travail (il peut sembler magique sans comprendre les fermetures)
• Comment économiser beaucoup de code (et / ou de temps) avec des rappels

Ressources

• Je n'ai pas parcouru tout ce site, mais il semble être une excellente ressource, touchant ces sujets: http://eloquentjavascript.net/contents.html
• Consultez http://ejohn.org/apps/learn/ pour un excellent tutoriel sur Javascript

Je pense que la langue la plus essentielle 'Aha pour moi en Javascript était

• Fonctionne comme des objets
• Fermetures
• Orientation objet basée sur un prototype
• Portée en JavaScript

Pour tous ces sujets, vous devriez trouver de nombreuses ressources sur le Web.

(Et ne pensez pas que tout deviendra totalement logique: JavaScript est source de confusion)

javascript était difficile pour moi quand j'ai commencé à l'apprendre il y a quelques années parce que j'ai commencé à apprendre le développement web du côté serveur (php et perl).

Ce n'était pas tant la syntaxe ou la POO ou quelque chose qui m'échappait, plus la vie en direct et pilotée par les événements de javascript - allant de "faire ceci et cela et cela et le servir et vous avez terminé" pour "faire cela et ceci et ceci et puis nous sommes dans un état constant d'attendre que quelque chose se produise et de répondre jusqu'à ce que l'utilisateur quitte la page ". Cela m'a vraiment jeté une boucle.

Je ne pense pas pouvoir nommer quoi que ce soit en particulier qui l'ait vraiment fait sombrer (pas de moment "aha!" Définitif - si je devais nommer un moment spécifique, je dirais quand j'apprenais AJAX pour un script de suggestion de recherche, mais IMO c'est juste arbitraire) mais quand j'ai finalement compris la différence, tout est devenu beaucoup plus facile à partir de là :)

Quand j'ai finalement compris l'idée que je pouvais redéfinir n'importe quelle partie de la langue à n'importe quelle merde que je voulais. À cet égard, c'est encore plus puissant que C. Par exemple, si je n'aime pas la toString()fonction standard , je vais implémenter la mienne:

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

Quand j'ai réalisé que vous pouviez définir une propriété sur un objet fonction.

Aussi quand j'ai finalement compris ce qu'était le prototype.

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??

Et le moment a -ha où vous saisissez enfin ces résultats.

Aha moment # 1, pour moi: Réaliser que JavaScript, le langage, est distinct de son utilisation principale: HTML dynamique et programmation web côté client. Je serais frustré par JavaScript, alors que j'étais vraiment frustré par les incompatibilités du DOM et du navigateur.

Aha moment # 2: Comprendre que l'héritage peut être exécuté de plusieurs façons. L'héritage classique basé sur une classe n'en est qu'un. Il en existe d'autres, à savoir basés sur des prototypes (le style utilisé en JavaScript).

En ce qui concerne # 1, je ne peux m'empêcher de recommander JavaScript: les bonnes parties . Il traite JavaScript comme un beau langage à part entière.

Pas de délimitation et de levage des blocs.

foo(); // function executes, no error

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

C'est juste un schéma avec une syntaxe.

C'était le gros pour moi.

jQuery était fondamentalement le moment «a-ha» pour moi. La syntaxe m'a semblé familière après avoir beaucoup d'expérience avec la syntaxe LINQ / lambda en C #.