Java et JavaScript ne sont pas la même chose! Vous connaissez maintenant le principal secret des maçons. Dans cet article, je veux partager avec vous des réflexions et des réflexions sur le langage JavaScript à travers les yeux d'un développeur Java. Je vais comparer les structures de données, les types, les fonctions, les objets, les classes et d'autres fonctionnalités courantes de Java et JavaScript.
Fondation
JavaScript est un langage de script interprété pour l'écriture de scripts. Cela signifie que le code que vous écrivez sera exécuté ligne par ligne, d'instruction en instruction, de script en script.
Java est un langage compilé, ce qui signifie qu'avant de démarrer un programme Java, le compilateur doit traduire tout le code que vous avez écrit en un code machine spécial compréhensible pour la JVM -
bytecode .
Les inconvénients pour un développeur Java qui a commencé à écrire en JS en rapport avec ces différences seront les suivants:
- Avant de commencer la compilation de votre code écrit en Java, le compilateur effectuera l'analyse syntaxique et sémantique pour vous, et en cas de problème, vous en informera. Il s'avère que vous avez la possibilité de découvrir l'erreur avant de lancer l'application. Dans JS, en raison de l'absence d'un compilateur, il n'y a pas de vérification de ce type. Et les erreurs commises par vous au moment de l'écriture du code ne seront détectées qu'après le lancement du script.
- L'inconvénient suivant n'est possible que pour les versions JS antérieures à ES5. Parce que JavaScript est exécuté ligne par ligne, le style des fonctions d'écriture qui appellent d'autres fonctions sera différent des principes du code pur "oncle" de Bob , prêché pour écrire des programmes en Java. Dans JS, si vous devez appeler la fonction bar () à partir de la fonction foo () , vous devez définir bar () avant foo () . Si vous faites le contraire, comme dans Java - applications, l'appel peut échouer dans certains navigateurs plus anciens.
Variables et leurs types
JavaScript est un langage faiblement typé, contrairement à Java. D'une part, cela donne plus de flexibilité, d'autre part - plus de possibilités de tirer une balle dans la jambe. Pour déclarer une variable en JS, il suffit d'utiliser le mot-clé
var , après quoi indiquer le nom de la variable et, si nécessaire, la valeur. En pratique, il n'est même pas nécessaire d'utiliser le mot-clé
var .
var name_1 = "Igor Ivanovich"; name_2 = "Renat Raphaelevich";
Maintenant sur les types. Dans JS, il n'y a pas de types différents pour les entiers et les nombres à virgule flottante. Ils sont combinés en
numéro de type.
String ,
boolean sont les mêmes qu'en Java. JS a un type d'
objet . Si en Java c'est une superclasse de toutes les classes, alors en JS ce n'est qu'un des types.
var a_number = 10;
Le développeur Java ne doit pas être confondu. Essayons maintenant d'effectuer des opérations entre des objets de différents types et voyons ce qui se passe.
10 +1 > 11 10 +"1" > "101" true && false > false true && 1 > 1 true && 0 > 0 true && "1" > "1" false && "1" > false false && 0 > false 0.1 + 0.7 > 0.7999999999999999
Certains résultats peuvent dérouter un peu le développeur Java. Par exemple, la possibilité d'utiliser le type
booléen de cette manière:
true && 1 et en même temps obtenir une sorte de résultat. En Java, il est impossible d'effectuer une telle opération car le compilateur donnera une erreur indiquant que vous ne pouvez pas utiliser l'opérateur && avec des types autres que
booléens . Faisons maintenant attention à une autre différence entre JS et Java:
les opérateurs === et
! == . Ce sont des opérations de comparaison nécessaires à un langage faiblement typé tel que JS.
=== - retournera vrai si les objets comparés ont une valeur égale et que leurs types coïncident.
! == , respectivement, renverra true si les objets comparés n'ont pas la même valeur ou si leurs types ne correspondent pas. Regardons quelques exemples:
10 == 10 > true 10 == "10" > true 10 === "10" > false 10 != "10" > false 10 !== "10" > true 10 !== 10 > false
Les fonctions
En JS, ainsi qu'en Java, les fonctions peuvent retourner / ne pas retourner une valeur, avec ou sans arguments. Vous pouvez appeler la fonction à la fois dans le code JS, comme indiqué dans l'exemple ci-dessus, et en répondant à un événement spécifique sur l'élément de balisage html.
<!-- --> <input type="button" value="CLICK" onclick="foo();"> // foo() function foo() { document.write("Calling foo"); }
Lorsque vous cliquez sur le bouton de la page, «Calling foo» sera imprimé à la suite de l'appel de la fonction. Maintenant sur les bizarreries auxquelles un développeur Java pourrait prêter attention. Revenons à l'exemple ci-dessus, où la fonction
foo () appelle la fonction
bar () en elle-même - qui n'est utilisée qu'en tant que fonction interne. Selon l'idée, nous nous attendons à ce qu'il puisse être rendu privé. Mais il n'y a pas de sélecteurs d'accès dans JS. Il n'y a aucun moyen de faire du champ
privé une simple addition de ce mot avant la déclaration de fonction. Allons plus loin. Créons un objet - une instance d'une classe avec ses champs et une méthode.
function getLocation() { if (this.person === "Igor" && this.age > 25) { document.write("Your name " + this.person + ", location = Vishnevaia 1"); } else { document.write("Your name " + this.person + ", location = rp Sokoloviy"); } } function Person(person, age) { this.person = person; this.age = age; this.getLocation = getLocation; } var igor = new Person("Igor", 26); igor.getLocation(); document.write("<br />"); getLocation();
Si vous regardez ce code à travers les yeux d'un développeur Java, vous pouvez noter que la fonction
Person est un constructeur d'objets de la classe
Person et une définition des champs et des méthodes inclus dans la classe. La fonction
getLocation () est une fonction de la classe
Person . À l'intérieur, nous utilisons l'accès aux champs de la classe d'instance
this.person et
this.age . Il est logique que cette fonction utilisant l'instance actuelle de la classe
Person ne fonctionne qu'avec elle et que le dernier appel à la fonction
getLocation () ne fonctionne pas. Mais, dans JS, c'est normal, car les concepts de classe, fonction, méthodes de classe sont flous. Faible frappe en tout. En exécutant ce script, vous recevrez la sortie suivante dans la fenêtre du navigateur:
Your name Igor, location = Vishnevaia 1 Your name undefined, location = rp Sokoloviy
Cependant, en réécrivant le code comme suit, en définissant une fonction à l'intérieur de la classe, son appel n'est pas disponible pour l'instance de classe:
function Person(person, age) { this.person = person; this.age = age; this.getLocation = function () { if (this.person === "Igor" && this.age > 25) { document.write("Your name " + this.person + ", location = Vishnevaia 1"); } else { document.write("Your name " + this.person + ", location = rp Sokoloviy"); } }; } var igor = new Person("Igor", 26); igor.getLocation(); document.write("<br />"); getLocation();
Le dernier appel entraînera une erreur, car la fonction
getLocation () n'est pas définie. Il s'avère que même dans JS, il n'y a pas de modificateurs d'accès, mais il existe un éventail de fonctions et de variables contrôlées avec des accolades. JavaScript est merveilleux avec un grand nombre d'options pour se tirer une balle dans le pied.
Tableaux
Lorsque nous parlons de tableaux, nous représentons une structure de données qui stocke le même type d'éléments, auxquels on accède par index. C'est en Java. Quand il s'agit de JS et de sa frappe faible, la véritable anarchie entre en jeu. Dans l'exemple suivant, nous créons 4 tableaux. Dans le premier, il y a des éléments de différents types, dans le second uniquement des nombres, dans le troisième
booléen , dans le quatrième
booléen et le
nombre :
var mix = [3, "Igor Ivanovich", "Renat Raphaelevich", "Sergey Sergeevich", 1, 12.3, true]; var numbers = [1,2,3,4,5]; var booleans = [false, false, true]; var mix2 = [false, 1, 2]; document.write("Type elements in mix: "); for (element in mix) { document.write(typeof mix[element] + " "); } document.write("<br /> Type elements in numbers: "); for (element in numbers) { document.write(typeof numbers[element] + " "); } document.write("<br /> Type elements in booleans: "); for (element in booleans) { document.write(typeof booleans[element] + " "); } document.write("<br /> Type elements in mix2: "); for (element in mix2) { document.write(typeof mix2[element] + " "); } var sum = numbers[0] + numbers[1]; document.write("<br /> sum numbers = " + sum);
Après avoir exécuté le script, nous verrons le type de chaque élément de chaque tableau et la somme des deux premiers chiffres du tableau de nombres.
Type elements in mix: number string string string number number boolean Type elements in numbers: number number number number number Type elements in booleans: boolean boolean boolean Type elements in mix2: boolean number number sum numbers = 12
Conclusion
Lorsque vous touchez pour la première fois le langage JavaScript, le développeur Java peut rencontrer tous les commentaires et questions ci-dessus. Quand j'ai rencontré JS pour la première fois, je n'ai pas ressenti les émotions les plus amusantes. C'était plutôt comme ceci: "Qu'est-ce que ...?" De nombreuses différences et malentendus résident dans la différence entre les typifications de deux langues. Je ne sais pas pourquoi JS a besoin d'une frappe faible.
Il y a peut-être des avantages à cela. Si vous connaissez la réponse, écrivez dans les commentaires.
Oui, il y a TypeScript, qui semble être tapé, mais à la fin il sera traduit dans le même JS. Personnellement, je ne suis pas partisan de la frappe faible, mais mon collègue, qui a récemment essayé JavaScript, en était ravi pour une raison quelconque. C'est peut-être une question de goût. Et qu'est-ce qui, selon vous, est meilleur qu'un typage faible ou fort?