LiveScript, ECSMAScript = JavaScript

Nous pouvons désormais facilement répondre à Gmail, avec ses pop-ups, ses messages instantanés, et tout cela sans recharger la page. Mais au début des années 90, les programmes pour Windows pouvaient le faire, et puis avec une très grande ampleur, tout en imposant leur nature d'applications autonomes. En fait, le problème identifié est le manque d'interactivité sur les pages Web, uniquement du texte sec avec des images et des hyperliens. Les ingénieurs de la société Netscape de l'époque (aujourd'hui Mozilla) étaient préoccupés par ce problème, et ici cela vaut la peine de commencer l'histoire de Javascript.

Le jeune ingénieur Brendan Icke a été chargé de créer un langage qui serait similaire à Java, mais qui serait plus petit et, comme l'auteur lui-même l'a écrit, « comme son jeune frère », et surtout, aurait un vocabulaire expressif pour que les non-programmeurs pourraient rapidement maîtriser la technologie. Après 10 jours, la première version du langage a été écrite, qu'ils ont décidé d'appeler LiveScript. Bien sûr, il est difficilement possible de créer un langage idéal en peu de temps, mais, malgré certaines de ses lacunes, il a résolu la tâche qui lui était assignée, à savoir qu'il permettait de travailler avec HTML sans recharger la page.

Après un certain temps, le langage a été renommé JavaScript. Ce nom n'a pas été choisi par hasard. A cette époque, et comme maintenant, Langage Javaétait très populaire et le préfixe du mot Java était censé attirer davantage l'attention sur le langage. Et cela a porté ses fruits, les gens se sont intéressés, l'ont essayé, ont apprécié les capacités du langage, à tel point qu'après l'annonce de la technologie, plus de 20 entreprises ont exprimé leur intention d'utiliser Javascript dans leurs futurs produits comme langage de script objet avec un standard ouvert (basé sur Wikipédia). Et c'était en 1995.

La même année, à la demande de Netscape, le langage est standardisé par l'ECMA (European Computer Manufacturers Association) et reçoit le nom d'ECMAScript. La version actuelle du document est la 5.1, qui est prise en charge par la plupart des navigateurs modernes.

Maintenant, cela crée de la confusion, les gens sont parfois confus au sujet des noms LiveScript, JavaScript et ECSMAScript. Mais si l’on omet la différence entre les concepts de standard et de langage de programmation, alors il n’y a pas de différence en tant que telle ; l’histoire et les entreprises l’ont décrété.

Concepts essentiels pour votre code

Javascript s'est beaucoup développé depuis 1994. Il s'agit désormais d'un langage fullstack, ce qui signifie que vous pouvez y écrire un site Web à part entière, sans utiliser de langage de programmation côté serveur supplémentaire, par exemple . Cela est devenu possible après l'apparition du moteur V8 développé par Google et la plateforme serveur node.js basée sur celle-ci.

Il convient de souligner deux caractéristiques très importantes du langage : les fermetures et le contexte d'exécution.

• Les fermetures sont la possibilité d'accéder aux variables disponibles à l'emplacement de déclaration de la fonction ;
• Le contexte d'exécution est l'endroit où cette référence se transforme en objets au sein d'une fonction, en fonction de la personne pour qui la fonction est exécutée.

Ce sont des concepts à la fois assez simples et complexes, dont la compréhension vient avec la pratique. Mais les mal comprendre est le plus cause commune erreurs dans le code.

Javascript est Java ?

Peut-être la question la plus courante sur Internet. Comme vous l’avez déjà compris, la réponse est négative. La similitude de nom n’est qu’un stratagème marketing. JavaScript hérite de certaines fonctionnalités de Java, mais rien de plus. Le tableau décrit les différences les plus évidentes.

Javascript

Interprétable		Compilé
Cela signifie que le code que vous écrivez en Javascript peut être exécuté immédiatement, sans compilation. À son tour, le code Java doit d'abord être converti en bytecode, qui est ensuite exécuté par la machine virtuelle.
Saisie dynamique	Statique
Le typage dynamique signifie que dans différentes parties du programme, la même variable peut prendre des valeurs divers types. Par exemple, lors de la déclaration d'une variable, vous l'avez définie comme une chaîne, mais lors de l'exécution, vous lui avez attribué une valeur numérique. Javascript interprète ce code sans erreur, mais le compilateur Java générera une erreur.
Prototypiquement orienté objet	Classe orientée objet
En Javascript, l'élément central est constitué d'objets prototypes, qui peuvent changer au fur et à mesure de l'exécution du programme et être clonés pour créer d'autres objets. C'est ce qu'on appelle la programmation de prototypes. Il existe deux concepts clés en Java, la classe et l'objet. Avant qu’un objet puisse être utilisé, il doit être décrit comme une classe. Il s’agit de ce qu’on appelle la programmation de prototypes basée sur les classes.

Résumer. Où commencer?

JavaScript est actuellement le langage de programmation côté client le plus populaire. Si vous en avez déjà entendu parler et que, après avoir lu l'article, vous avez décidé de l'étudier, ProstoWeb en a préparé plusieurs pour vous. ressources utiles pour les débutants:

Sites Internet

• http://javascript.ru – numéro un sur RuNet ;
• https://developer.mozilla.org/ru/docs/JavaScript - les dernières informations sur les plus sujets d'actualité langue. La plupart des articles couvrent des sujets plus profonds, mais il existe également des informations de base sur la langue (anglais).

J'ai promis d'écrire un article sur l'utilisation de GraalVM pour mélanger Java et JS. Elle est là.

Quel est le problème? Dans la pratique quotidienne, nous rencontrons souvent des applications composées de deux parties : un frontend JavaScript et un backend Java. Organiser une interopérabilité entre eux demande des efforts. En règle générale, ils sont fabriqués par des personnes ayant différents côtés des barricades, et lorsqu'ils essaient d'entrer dans la zone de quelqu'un d'autre, ils commencent à souffrir. Il existe aussi des développeurs web full-stack, mais tout est clair chez eux : ils doivent toujours souffrir.

Dans cet article, nous examinerons une nouvelle technologie qui peut rendre le processus un peu moins pénible. Plus précisément, la méthode existe depuis assez longtemps, mais a en quelque sorte retenu l'attention du grand public.

Si l'un des Javaistes n'a pas encore écrit en React, il y aura ici un tutoriel qui vous permettra de le faire. Si aucun des Javascripteurs n'a essayé d'écrire en Java, alors dans ce didacticiel, vous pourrez en parler (bien que sur une seule ligne et via les liaisons JS).

JS->Java. Faisons bouger les choses : Nashorn

Si vous souhaitez une interopérabilité Java->JS, il existait une telle technologie dans le JDK il y a longtemps, et elle s'appelle Nashorn (lire : « Nashorn »).

Prenons une situation réelle. De temps en temps, d'année en année, les gens continuent d'écrire des validateurs « serveur » en Java et des validateurs « client » en JS. Le cynisme particulier ici est que les contrôles coïncident souvent à 80 %, et toute cette activité est en fait une forme particulière de perte de temps.

Imaginons que nous ayons un validateur très stupide :

var validate = function(target) ( if (target > 0) ( return "success"; ) else ( return "fail"; ) );

Nous pouvons le lancer sur les trois plateformes :

• Navigateur
• Noeud.js

Dans un navigateur, c'est trivial. Nous intégrons simplement ce morceau de code n'importe où, et cela fonctionne.

Dans Node.js, vous devez soit respecter leur approche feng shui de l'utilisation de require, soit le pirater avec ce code simple :

var fs = require("fs"); var vm = require("vm"); var includeInThisContext = function(chemin) ( var code = fs.readFileSync(chemin); vm.runInThisContext(code, chemin); .bind(this); includeInThisContext(__dirname + "/" + nom de fichier);

Préparez-vous au fait que si vous utilisez de telles techniques, vos collègues pourraient bientôt commencer à vous considérer comme un épouvantail. Nous, Javaistes, n'y sommes pas étrangers, mais les Javascripteurs professionnels peuvent être gênés.

Maintenant nous allons faire la même chose, mais sous Nashorn en Java.

public class JSExecutor ( private static final Logger logger = LoggerFactory.getLogger(JSExecutor.class); moteur ScriptEngine = new ScriptEngineManager().getEngineByName("nashorn"); invocable invocable = moteur (invocable); public JSExecutor() ( try ( File bootstrapFile = new ClassPathResource("validator.js").getFile(); String bootstrapString = new String(Files.readAllBytes(bootstrapFile.toPath())); engine.eval(bootstrapString); ) catch (Exception e) ( logger. error("Impossible de charger le bootstrap JS!", e); ) ) public Object perform(String code) ( Object result = null; try ( result = engine.eval(code); ) catch (Exception e) ( logger. error("Impossible d'exécuter JS!", e); ) return result; ) public Object executeFunction(String name, Object... args) ( Object result = null; try ( result = invocer.invokeFunction(name, args) ; ) catch (Exception e) ( logger.error("Can"t run JS!", e); ) return result; ) )

Comme vous pouvez le voir, vous pouvez extraire à la fois du code arbitraire et une fonction distincte par son nom.

Il existe bien sûr des problèmes qui ne peuvent être résolus qu'en manuellement. Par exemple, vous pouvez créer un polyfill comme ceci :

var global = ceci ; var fenêtre = ceci ; var processus = (env:()); var console = (); console.debug = imprimer; console.log = imprimer; console.warn = imprimer; console.erreur = imprimer;

Si vous souhaitez que le code du validateur soit parfaitement identique sur le serveur et sur le client, vous devrez écrire des stubs pour les méthodes « serveur », qui sont poussées uniquement dans le navigateur. Ce sont déjà des détails d’une implémentation spécifique.

À propos, ab sur mon ordinateur portable (ab -k -c 10 -n 100 http://localhost:3000/?id=2) affiche 6 à 7 000 requêtes par seconde pour ce code, et peu importe quoi il fonctionne sur Nashorn ou Node.js. Mais il n'y a rien d'intéressant à cela : d'une part, ab sur localhost mesure la météo sur Mars, et d'autre part, on pense déjà qu'il n'y a pas d'erreurs évidentes dans ces moteurs, ce sont des concurrents.

Il est clair que si vous vivez dans la « zone rouge » de la courbe Sh., vous ne pouvez pas utiliser Nashorn sans allumer votre cerveau et écrire des benchmarks. Si vous réfléchissez bien, vous pouvez écrire un benchmark où Nashorn s'affaissera, et il serait plus correct d'écrire du code natif. Mais nous devons clairement comprendre que le monde ne se limite pas aux thèmes de forte charge et de performance, parfois la commodité d'écriture est plus importante que n'importe quelle performance.

Java->JS. Problème

Essayons de pousser les données dans la direction opposée, de Java vers JS.

Pourquoi cela pourrait-il être nécessaire ?

Premièrement, et surtout, dans de nombreuses entreprises, il existe un axiome indiscutable : nous utilisons Java. Dans certaines banques. Deuxièmement, au cours de la résolution de problèmes quotidiens, de telles tâches surviennent constamment.

Prenons un cas de jouet de la vie réelle. Imaginez : vous devez générer un front avec webpack et vous souhaitez l'insérer dans le bon coin supérieur pages Web version actuelle de l'application. Il est probable que la version backend puisse être extraite de la manière normale uniquement en appelant du code Java (hérité). Cela signifie que vous devez créer un projet Maven qui fonctionnera en deux passes : attacher à une phase du cycle de vie de build Maven l'assemblage de quelques classes et leur lancement, ce qui générera un fichier de propriétés avec un numéro de version, qui être récupéré par npm appelé manuellement dans la phase suivante.

Je ne donnerai pas d'exemple d'un tel pom.xml ici, car c'est dégoûtant :)

Plus généralement, le problème est que la culture moderne soutient et encourage les programmeurs polyglottes et les projets écrits dans plusieurs langues. De là découlent les points suivants :

• Les développeurs souhaitent utiliser le langage qui convient le mieux au problème posé. Il est très pénible d'écrire une interface Web en Java (au moins jusqu'à ce que la JVM et OpenJDK se stabilisent sur WebAssembly), mais en JS c'est simple et pratique.
• Souvent, vous souhaitez développer plusieurs bases de code en parallèle. Par exemple, il y a une base en JS - front et une autre base en Java - back. Je voudrais développer des projets, en réécrivant lentement l'intégralité de l'application dans Node.JS, y compris le code du serveur - dans les endroits où Java n'est pas vraiment nécessaire. Il ne devrait pas y avoir de « jour numéro zéro » lorsque l'ensemble du backend Java ou du frontend JS va à la casse, et laisser le monde entier attendre que nous en écrivions un nouveau.
• Lorsque vous franchissez une frontière linguistique, vous devez écrire manuellement beaucoup de code inutile qui fournit l'interopérabilité.

Parfois il y a solutions prêtes à l'emploi- par exemple, franchir la frontière Java/C se fait à l'aide de JNI.

L’utilisation d’une telle intégration est également une bonne chose car, comme aiment le dire les programmeurs fonctionnels, « ce qui n’existe pas ne se brisera pas ». Si nous prenons en charge les infernaux pom.xml, les propriétés et les fichiers XML ainsi que d'autres interopérabilités manuelles dans notre code, alors ils ont tendance à s'introduire le plus souvent dans notre code. moments désagréables. Si cette couche a été écrite par de vrais nerds du combat, comme Oracle ou Microsoft, elle ne se casse presque pas, et quand elle se casse, ce n'est pas à nous de la réparer.

Revenant à l'exemple précédent : pourquoi devons-nous nous lever deux fois et faire des miracles avec Nashorn, si nous ne pouvons pas nous lever du tout et écrire l'intégralité de l'interface utilisateur uniquement sur Node ?

Mais comment faire cela, étant donné que vous devez aspirer de manière transparente les données de Java ?

La première pensée qui me vient à l’esprit est de continuer à utiliser Nashorn. Aspire tout dedans bibliothèques requises, déposez-le, et peut-être qu'ils commenceront même. Si parmi eux personne n’a besoin d’extensions natives. Et émulez manuellement l’ensemble de l’infrastructure Node. Et quelque chose d'autre. Cela semble être un problème. En général, il existait déjà un tel projet, il s'appelait Projet Avatar et, malheureusement, il est mort. Si les développeurs d'Oracle n'ont pas pu le réaliser, quelle est la chance qu'ils puissent le faire eux-mêmes ?

Java->JS. Graal

Heureusement, nous en avons un autre qui est assez nouveau et projet intéressant-Graal.js. C'est-à-dire la partie de Graal responsable de l'exécution de JavaScript.

Les projets innovants du monde du JDK sont souvent perçus comme quelque chose de lointain et d’irréel. Graal est différent à cet égard : il est apparu très soudainement en tant que concurrent mature.

Graal ne fait pas partie d'OpenJDK, mais un produit distinct. Il est célèbre pour le fait que dernières versions OpenJDK, vous pouvez basculer le compilateur JIT de C2 vers celui fourni avec Graal. De plus, Graal est livré avec le framework Truffle, qui peut être utilisé pour implémenter divers nouveaux langages. Dans ce cas, les développeurs d'Oracle Labs ont implémenté la prise en charge de JavaScript.

Pour avoir une idée de sa simplicité et de sa commodité, examinons un exemple de projet de jouet.

Imaginons que nous abattions un OVNI sur Habré.

Dans la première version de Slashing, UFO pourra bannir des personnes aléatoires, et le bouton s'appellera « Ban quelqu'un ! » Dans la deuxième version, le bouton interdira soit les trolls, soit les spammeurs, et ceux que nous interdisons maintenant seront chargés depuis Java. Afin de minimiser l'exemple, seule l'étiquette du bouton changera ; nous ne modifierons pas la logique métier.

Il existe de nombreuses étapes pour créer une application React, elles sont donc soigneusement divisées en étapes. Au final, j'obtiens une application fonctionnelle, j'ai vérifié.

Partie 1. Préparation de la demande1. Téléchargez le GraalVM « entreprise » (via le lien) et définissez les variables d'environnement Java habituelles.

La version Enterprise est nécessaire car c'est la seule qui dispose de GraalJS.

Vous pouvez, par exemple, écrire ceci dans .bash_profile :

graalvm () ( export LABSJDK=/Users/olegchir/opt/graalvm-0.33/Contents/Home export LABSJRE=/Users/olegchir/opt/graalvm-0.33/Contents/Home/jre export JDK_HOME=$LABSJDK export JRE_HOME=$LABSJRE export JAVA_HOME=$JDK_HOME export PATH=$JDK_HOME/bin:$JRE_HOME/bin:$PATH )

Et puis après avoir redémarré le shell, appelez cette fonction : graalvm.

Pourquoi est-ce que je suggère de créer une fonction bash distincte et de l'appeler selon les besoins, plutôt que d'un seul coup ? Tout est très simple ici : une fois que GraalVM est entré dans le PATH, votre système npm normal (par exemple, /usr/local/bin/npm sur macOS) sera remplacé par notre version Java spéciale ($JDK_HOME/bin/npm). Si vous êtes un développeur JS, un tel remplacement permanent n'est pas la meilleure idée.

2. Créez un répertoire pour le projet mkdir -p ~/git/habrotest cd ~/git/habrotest 3. npm init (remplissez judicieusement, mais vous pouvez simplement cliquer sur le bouton Entrée)4. Installez les modules nécessaires : Webpack, Babel, React npm i --save-dev webpack webpack-cli webpack-dev-server npm i --save-dev babel-core babel-loader babel-preset-es2015 babel-preset-react npm je --save réagir réagir-dom

Notez que npm peut être légèrement obsolète (par rapport à la version "réelle") et vous demandera de le mettre à jour. Cela ne vaut pas la peine d'être mis à jour.

5. Créez les répertoires dans lesquels le travail aura lieu : mkdir -p src/client/app mkdir -p src/client/public mkdir -p loaders 6. Apprenez nos langages Babel :
( "presets" : ["es2015", "react"] ) 7. Configuration du webpack :

./webpack.config.js :

var p = require("chemin"); var webpack = require("webpack"); var BUILD_DIR = p.resolve(__dirname, "src/client/public"); var APP_DIR = p.resolve(__dirname, "src/client/app"); var config = ( sortie : ( chemin : BUILD_DIR, nom de fichier : "bundle.js" ), entrée : APP_DIR + "/index.jsx", module : ( règles : [ ( test : /\.jsx?/, include : APP_DIR , chargeur : "babel-loader" ) ] ) ); module.exports = config; 8. Créez une page pour notre application :

./src/client/index.html

Bienvenue dans la timonerie d'UFO 9. Créez un index (afin que nous puissions ensuite y insérer le composant de démonstration) :

./src/client/app/index.jsx

importer React depuis « react » ; importer (rendu) depuis « react-dom » ; importer NLOComponent depuis "./NLOComponent.jsx" ; la classe App étend React.Component ( render () ( return (

Bienvenue dans la timonerie, OVNI

); ) ) render(, document.getElementById("app")); 10. Créez un composant !

./src/client/app/NLOComponent.jsx

importer React depuis « react » ; la classe NLOComponent étend React.Component ( constructor(props) ( super(props); this.state = (banned: 0); this.onBan = this.onBan.bind(this); ) onBan() ( let newBanned = this. state.banned + 10; this.setState((banned: newBanned)); ) render() ( return ( Interdire quelqu'un ! 11. Exécutez le build : webpack -d

Tout devrait s'assembler avec succès et produire quelque chose comme :

joker:habrotest olegchir$ webpack -d Hash : b19d6529d6e3f70baba6 Version : webpack 4.5.0 Temps : 19358 ms Construit à : 2018-04-16 05:12:49 Taille de l'actif Morceaux Noms des morceaux bundle.js 1,69 Mo main main Point d'entrée main = bundle. js [./src/client/app/NLOComponent.jsx] 3,03 KiB (principal) [./src/client/app/index.jsx] 2,61 KiB (principal) + 21 modules cachés 12. Vous pouvez maintenant l'ouvrir dans le browser./src/client/index.html et profitez de la vue suivante :

La première partie du tutoriel est terminée, vous devez maintenant apprendre à changer l'étiquette du bouton.

Partie 2. On glisse des variables13. Essayons d'implémenter dans notre composant les variables « nom du bouton » (buttonCaption) et « liste d'options » (buttonVariants), dont on ne sait rien en JS. À l'avenir, ils seront extraits de Java, mais pour l'instant vérifions simplement que leur utilisation entraîne une erreur : import React from "react" ; la classe NLOComponent étend React.Component ( constructor(props) ( super(props); this.state = (interdit : 0, bouton : buttonCaption); this.onBan = this.onBan.bind(this); ) onBan () ( let newBanned = this.state.banned + 10; this.setState((banned: newBanned, bouton: boutonVariants)); ) render() ( return ( Nombre de bannis : (this.state.banned) (this.state.button) ) ; ) ) exporter le NLOComponent par défaut ;

Nous voyons une erreur honnête :

NLOComponent.jsx?8e83:7 Uncaught ReferenceError : ButtonCaption n'est pas défini dans le nouveau NLOComponent (NLOComponent.jsx?8e83:7) dans constructClassInstance (react-dom.development.js?61bb:6789) dans updateClassComponent (react-dom.development. js?61bb:8324) sur beginWork (react-dom.development.js?61bb:8966) sur performUnitOfWork (react-dom.development.js?61bb:11798) sur workLoop (react-dom.development.js?61bb:11827) ) sur HTMLUnknownElement.callCallback (react-dom.development.js?61bb:104) sur Object.invokeGuardedCallbackDev (react-dom.development.js?61bb:142) sur EnsureGuardedCallback (react-dom.development.js?61bb:191) à replayUnitOfWork (react-dom.development.js?61bb:11302) (anonyme) @ bundle.js:72 réagir-dom.development.js?61bb:9627 L'erreur ci-dessus s'est produite dans le composant : dans NLOComponent (créé par App) dans div (créé par App) dans l'application 14. Faisons maintenant connaissance avec de manière légale insérez des variables dans Webpack. Ce sont des chargeurs.

Tout d’abord, vous devez réécrire légèrement la configuration du webpack afin de charger facilement les chargeurs personnalisés :

var p = require("chemin"); var webpack = require("webpack"); var BUILD_DIR = p.resolve(__dirname, "src/client/public"); var APP_DIR = p.resolve(__dirname, "src/client/app"); let defaults = ( sortie : ( chemin : BUILD_DIR, nom de fichier : "bundle.js" ), entrée : APP_DIR + "/index.jsx", module : ( règles : [ ( test : /\.jsx?/, include : APP_DIR , chargeur : "babel-loader" ) ] ), solveLoader : ( modules : ["node_modules", p.resolve(__dirname, "loaders")] ) ); module.exports = fonction (contenu) ( let dd = valeurs par défaut; dd.module.rules.push(( test: /index\.jsx/, chargeur: "preload", options: () )); return dd; );

(Notez que vous pouvez mettre n'importe quelle donnée dans les options du chargeur, puis la lire en utilisant loaderUtils.getOptions(this) à partir du module loader-utils)

Eh bien, maintenant, en fait, nous écrivons un chargeur. Le chargeur est conçu bêtement : nous recevons le code original en entrée du paramètre source, nous le modifions à volonté (nous ne pouvons pas le modifier) ​​puis le renvoyons.

./loaders/preload.js :

const loaderUtils = require("loader-utils"), schemaUtils = require("schema-utils"); module.exports = function main(source) ( this.cacheable(); console.log("applying loader"); var initial = "Ban the troll!"; var variants = JSON.stringify(["Ban the troll!"; , " Bannissez le spammeur ! "]); return `window.buttonCaption=\"$(initial)\";` + `window.buttonVariants=$(variants);` + `$(source)`; );

Nous reconstruisons en utilisant webpack -d .

Tout fonctionne bien, il n'y a aucune erreur.

Partie 3. Ajouter du code Java15. Maintenant, vous vous demandez : d'accord, nous avons appris un sale petit hack de Webpack, mais qu'est-ce que Java a à voir avec cela ?

Ce qui est intéressant ici, c'est que notre chargeur ne s'exécute pas comme ça, mais sous le Graal. Cela signifie qu'en utilisant une API similaire à celle de Nashorn, vous pouvez travailler à partir de JS avec des types Java.

const loaderUtils = require("loader-utils"), schemaUtils = require("schema-utils"); module.exports = function main(source) ( this.cacheable(); console.log("applying loader"); //Nous pouvons obtenir des types Java et créer des objets de ce type var JavaString = Java.type("java.lang . String"); var initial = new JavaString("Ban le troll!"); //Nous pouvons convertir les données dans les deux sens var jsVariants = ["Ban le troll!", "Ban le spammeur!"]; var javaVariants = Java .to(jsVariants, "java.lang.String"); var variants = JSON.stringify(javaVariants); //Mais l'interopérabilité n'est pas toujours bonne, et ensuite il faut utiliser des béquilles return `window.buttonCaption=\" $(initial)\ ";` + `window.buttonVariants=$(variants);` + `$(source)`; );

Et bien sûr, webpack -d .

16. Lorsque nous essayons de construire avec webpack, nous voyons l'erreur : ERREUR dans ./src/client/app/index.jsx La construction du module a échoué : ReferenceError : Java n'est pas défini dans Object.main (/Users/olegchir/git/habrotest /loaders/preload.js:9:19)

Cela se produit parce que les types Java ne sont pas disponibles par défaut et sont activés par un indicateur spécial --jvm , qui n'est disponible que dans GraalJS, mais pas dans Node « normal ».

Par conséquent, vous devez le récupérer avec une commande spéciale :

nœud --jvm node_modules/.bin/webpack -d

Comme taper tout cela est assez fastidieux, j'utilise un alias dans bash. Par exemple, dans .bash_profile vous pouvez insérer la ligne suivante :

alias graal_webpack_build="node --jvm node_modules/.bin/webpack -d"

Ou quelque chose d’encore plus court pour rendre la frappe agréable.

17. BÉNÉFICES !

Le résultat peut être consulté dans mon référentiel GitHub. Fichiers collectés engagé directement dans le référentiel afin que vous puissiez le regarder sans même parcourir le didacticiel jusqu'à la fin.

Conclusion

De cette manière simple et pratique, nous pouvons désormais intégrer Java et JS. Tout cela est loin d’être un cas isolé : de nombreuses pistes d’application peuvent être envisagées.

Enfin, une goutte de pommade dans la pommade. Quel est le piège?

• GraalJS - pas encore Open source, même si, selon les rumeurs, ils souhaitent l'ouvrir en source libre ; Tout est déjà en ordre.
• Java npm est toujours lent. Pourquoi – nous devons étudier. C'est npm qui ralentit, pas le moteur JS lui-même ;
• Derrière tout cela se cache une magie féroce, et lorsque vous essayez d'y entrer, vous devrez étudier beaucoup de choses supplémentaires ;
• Tout cela est collecté par rapport au JDK8. Vous devrez attendre assez longtemps pour les nouvelles fonctionnalités de Java 11 ;
• Graal est un projet expérimental. Il faut en tenir compte lorsqu'on tente de l'intégrer dans une entreprise très sanglante, sans droit à l'erreur.

Balises : Ajouter des balises

Qu'est-ce que Java Qu'est-ce que JavaScript Pourquoi JavaScript a-t-il été appelé ainsi ? Comment Java a été créé Quelle est la différence entre Java et JavaScript

Commençons par ce que sont Java et Javascript.

Qu'est-ce que 'java?

Java est un langage de création de programmes, une plateforme informatique. Ceux. un programme qui traite les codes d'octet et transmet les instructions d'interprétation au matériel. Sun Microsystems a été fondée en 1995. Application Java est un bytecode spécial qui s'exécute sur n'importe quel ordinateur utilisant une machine virtuelle Java.

Par conséquent, de nombreux sites Web ne peuvent pas fonctionner sans Java. Java lui-même fonctionne rapidement, présente un bon niveau de sécurité et de fiabilité. Java est partout - dans consoles de jeux, dans nos téléphones, même dans le centre de données informatique. De plus, Java est absolument gratuit, vous pouvez toujours le mettre à jour vers la dernière version, ce que d'ailleurs ils disent que vous devriez toujours faire.

Qu’est-ce que Javascript ?

Voyons maintenant ce qu'est Javascript. Javascript est un langage de création de sites Web multi-paradigmes. Il comprend des styles tels qu'impératif, fonctionnel et orienté objet. Autrement dit, il est nécessaire pour créer des sites Web « en direct ». Contrairement à Java, Javascript a été inventé par Netscape, Inc. Cela signifie qu’il n’est en aucun cas lié à la plate-forme Java.

Aujourd’hui, Javascript est un langage de création de sites Web sécurisé et polyvalent. Il ne fonctionne pas avec les outils de bas niveau permettant de travailler avec la mémoire et les processus, car a été configuré sur le navigateur dès le début.

Pourquoi Javascript a-t-il été nommé ainsi ?

Plus tôt, nous avons découvert que Javascript avait été créé par des personnes complètement différentes. Alors pourquoi porte-t-il toujours un nom similaire ?

Cela est dû au fait que le langage de programmation Java était très célèbre à cette époque, ils ont donc décidé de tricher et l'ont appelé JavaScript. Ils l'appelaient à l'origine LiveScript. Ces gens avaient prévu qu'il soit le petit frère de Java. Mais maintenant, tout est complètement différent, Javascript s'est fortement développé et ne dépend plus de Java ni n'a rien à voir avec lui.

Il a été indiqué ci-dessus que Javascript ne devrait être utilisé que dans les navigateurs, mais maintenant JavaScript est également utilisé sur le serveur, il peut aujourd'hui être utilisé partout.

Comment Java a-t-il été créé ?

Dès le début, ils avaient prévu de l'appeler Oak. James Gosling a créé Java en tant que programme permettant de programmer des appareils électroniques du quotidien. Plus tard, renommant Oak en Java, ils décidèrent de l'utiliser pour écrire des applications client et serveur. logiciel. Ils ont décidé de lui donner le nom du café "Java". C'est pourquoi l'emblème de la langue représente une tasse de café chaud.

Regardons les principales différences.
Java est exprimé comme un langage orienté objet pour écrire divers programmes. Mais Javascript est Langage fonctionnel pour la production de scénarios.

Contrairement à Javascript, qui s'exécute principalement dans le navigateur, Java est nécessaire à la programmation diverses applications, qui s'exécute sur une machine virtuelle.

Javascript est généralement rendu tel qu'écrit, mais le code Java doit être compilé.

Pour eux, vous devez vous connecter ami différent modules les uns des autres.

Je suppose que cet article était très informatif et intéressant pour les lecteurs.

Tous. Ce sont des langues sans rapport.

2018-12-04T00:00Z

JavaScript est un langage orienté objet des scénarios, qui vous permet de créer des pages HTML dynamiques, permettant de traiter les entrées et de conserver les données, généralement dans le navigateur.

Java est un langage de programmation, un ensemble de bibliothèques de base et une plate-forme de machine virtuelle qui vous permet de créer des programmes compilés qui s'exécutent sur pratiquement toutes les plates-formes sans distribuer le code source dans sa forme originale ni le recompiler.

Bien qu'ils portent les mêmes noms, il s'agit en réalité de deux langages/modèles/plateformes de programmation complètement différents et sont utilisés pour résoudre complètement différentes tâches.

Une idée fausse courante est que JavaScript est similaire ou étroitement lié à Java ; c'est faux. Les deux ont une syntaxe de type C, sont orientés objet, sont généralement isolés et sont largement utilisés dans les applications Web côté client, mais les similitudes s'arrêtent là. Java est typé statiquement ; Le paramètre JavaScript est dynamique (ce qui signifie qu'une variable peut contenir un objet de n'importe quel type et ne peut pas être contrainte). Java est chargé à partir du bytecode compilé ; JavaScript se charge sous forme de code lisible par l'homme. C'est leur dernier langage mutuel ancêtres

2018-12-11T00:00Z

JavaScript a été nommé ainsi par Netscape pour confondre les imprudents en lui disant qu'il avait quelque chose à voir avec Java, le mot à la mode de l'époque, et il a réussi.

Les deux langues sont complètement différentes.

2018-12-18T00:00Z

Voici quelques différences entre les deux langues :

• Java est un langage typé statiquement ; JavaScript est dynamique.
• Java est basé sur les classes ; JavaScript est basé sur un prototype.
• Les constructeurs Java sont fonctions spéciales, qui ne peut être appelé que lors de la création d'un objet ; Les « constructeurs » JavaScript ne sont que des fonctions standard.
• Java exige que toutes les instructions non bloquantes se terminent par un point-virgule ; JavaScript insère des points-virgules à la fin de certaines lignes.
• Java utilise la mise à l'échelle des blocs ; JavaScript utilise la définition de la portée fonctionnelle.
• Java a une portée implicite pour les méthodes non statiques et une portée de classe implicite ; JavaScript a une portée globale cachée.

Voici quelques fonctionnalités que je considère comme des atouts particuliers de JavaScript :

• JavaScript prend en charge les fermetures ; Java peut simuler un tri de « fermeture » à l'aide de classes anonymes. (Les fermetures réelles pourraient être prises en charge dans une future version de Java.)
• Tous Fonctions JavaScript sont variables; Les fonctions Java ne sont des variables que si elles sont explicitement marquées.
• Les prototypes JavaScript peuvent être remplacés au moment de l'exécution et avoir un effet immédiat sur tous les objets référencés. Les classes Java ne peuvent pas être redéfinies d'une manière qui affecte les instances d'objet existantes.
• JavaScript vous permet de remplacer les méthodes d'un objet quel que soit son prototype (pensez à Ruby, mais sous stéroïdes) ; les méthodes d'un objet Java sont liées à sa classe et ne peuvent pas être remplacées au moment de l'exécution.

2018-12-25T00:00Z

Java et Javascript sont similaires, tout comme Car et Carpet.

2019-01-01T00:00Z

Presque tous les ordinateurs dans le monde vendent au moins un traducteur JavaScript installé.

La plupart (mais pas "presque tous") les PC ont une machine virtuelle Java installée.

Selon les statistiques de Github, Java et JavaScript sont actuellement les langages de programmation les plus populaires, après Python, PHP et Ruby. Malgré la similitude de leurs noms, c'est très différentes langues. Vous pourriez penser que JavaScript est un outil plus simple et plus léger. Version Java. Mais vous avez tort. Ce sont deux langages de programmation à part entière complètement différents qui vous permettent de faire des choses différentes, mais en même temps ils présentent plus de différences que de similitudes.

Dans cet article, nous examinerons la différence entre java et javascript pour vous aider à choisir le langage le mieux adapté pour résoudre vos problèmes. Comme vous le constaterez, les deux langues sont très rarement utilisées pour effectuer les mêmes tâches.

La première version de Java, nommée « Oak » et « Green » après le développement initial, a été publiée en mai 1995. De nombreux programmeurs à l'époque considéraient ce langage comme un remplacement du C/C++ car il avait une syntaxe similaire et introduisait également de nouveaux concepts. Le langage rendait la programmation plus facile et plus sûre.

L’un des principes fondamentaux de Java, qui a débuté à cette époque et perdure aujourd’hui, est l’idée selon laquelle les programmeurs peuvent écrire du code une fois et l’utiliser partout. Contrairement à compilé fichiers exécutables, qui ont différents formats pour différentes plates-formes, le code Java est compilé dans un seul fichier JAR qui peut être exécuté dans n'importe quel environnement compatible Java.

Ceci est rendu possible par la machine Java (JVM). Une machine Java est un programme classique qui sert d'intermédiaire entre système opérateur et fichier Jar. Il lit un fichier programme contenant des instructions Java et les transforme en instructions pour la plate-forme sur laquelle il s'exécute au moment de l'exécution. Ce processus est appelé compilation juste à temps ou JIT.

Qu'est-ce que JavaScript ?

JavaScript est apparu comme un langage simple pour créer des contraintes Formulaires HTML. Lorsque Netscape Communications a décidé de vouloir un Internet plus dynamique, ils ont créé un nouveau langage pouvant être utilisé directement dans HTML. Ce langage s'appelait LiveScript et a été développé en dix jours.

Le langage s'est ensuite développé pendant un certain temps sous ce nom, mais plusieurs raisons sont ensuite apparues pour changer le nom. Premièrement, JavaScript et Java étaient censés se compléter, donc JavaScript a reçu une syntaxe similaire, et deuxièmement, à cette époque, Java était très populaire, et donc les développeurs, afin d'attirer plus de personnes vers le langage, ont décidé d'utiliser un puits -mot connu dans le nom et remplacé Live en Java. C'est ainsi qu'est né JavaScript. Mais seule la syntaxe est similaire dans les langages ; plus tard, Java a été de moins en moins utilisé sur Internet et les langages ont divergé leurs chemins. De nos jours, HTML, CSS et JavaScript sont les principaux composants du développement Web.

Contrairement à Java, qui est compilé, JavaScript est un langage entièrement interprété. Lorsque vous visitez un site utilisant JavaScript, votre navigateur reçoit le code source complet du programme. Puis il est exécuté à la volée avec en utilisant Javascript moteur. Différents navigateurs utilisent différents moteurs : V8 (Chrome), SpiderMonkey (Firefox), Chakra (Edge), etc.

Aspects similaires de Java ou JavaScript

Malgré toutes les différences, ces langages présentent plusieurs similitudes qui peuvent être prises en compte même si vous n'avez pas l'intention d'utiliser les deux langages pour le développement Web. Voici les principaux :

• Objectivement programmation orientée(POO) - les deux langages exigent que le programmeur utilise les principes des objets et les relations entre eux lors du codage. Les deux langages prennent en charge les modèles POO tels que les interfaces, l'encapsulation et le polymorphisme.
• Développement Forend - Les deux langages peuvent être utilisés pour développer un forend, c'est-à-dire une interface utilisateur qui fonctionne en conjonction avec le serveur. JavaScript peut être intégré au HTML ou en tant que bibliothèque tierce sur les pages du site. Et Java peut s'exécuter dans le navigateur sous forme d'applet Java.
• Développement backend – en d’autres termes – développement de logiciels serveur. Java est utilisé depuis longtemps dans les technologies backend par les projets Apache, JBoss et WebSphere. Nouvelle technologie,Node.js vous permet d'exécuter des serveurs écrits en JavaScript.

Principales différences entre Java et JavaScript

Initialement, des langages ont été développés pour résoudre des problèmes complètement différents. Java est davantage destiné à créer des applications à part entière, tandis que JavaScript est un langage de script permettant d'organiser une interface sur le Web. Voici les principales différences pour faciliter la compréhension de la différence entre java et javascript :

• Compilabilité et interprétation - comme je l'ai écrit ci-dessus, Java est un langage de programmation compilé et JavaScript est interprété. La seule différence réside dans la mise en œuvre ; en fait, les deux langages peuvent fonctionner sur des plateformes différentes.
• Vérification de type statique et dynamique – Java utilise la vérification de type statique. Le type de la variable est vérifié au moment de la compilation. Le programmeur doit spécifier explicitement le type de la variable (chaîne, nombre, nombre à virgule flottante, etc.). JavaScript comme les autres langages de script utilise le typage dynamique. L'utilisation correcte des types est vérifiée au moment de l'exécution. Le programmeur n'a pas besoin de spécifier le type de la variable lors de sa déclaration. Les deux approches présentent de nombreux avantages et inconvénients. La différence la plus importante entre Java et Javascript est qu'avec le typage statique, la plupart des erreurs apparaissent au stade du développement, car le compilateur sait à quoi s'attendre, le code s'exécute plus rapidement et consomme moins de mémoire. L’avantage de la saisie dynamique est que les programmes sont écrits plus rapidement et plus facilement.
• Concurrence - la mise en œuvre de la possibilité d'exécuter plusieurs séquences d'instructions en même temps est très différente en Java et en JavaScript. Java vous permet d'utiliser plusieurs threads pour exécuter des tâches parallèles. La mise en œuvre de la concurrence en JavaScript est très complexe. Il n'est disponible que dans Node.js. Sur le thread principal, cela est implémenté via une file d’attente d’exécution appelée boucle d’événements. Les deux méthodes fonctionnent bien, mais les threads Java sont plus rapides.
• Classes et objets - Java utilise des classes et des relations entre elles. Les propriétés d'un objet sont définies dans une classe et constituent une partie immuable de la classe. Vous pouvez hériter des classes d'autres classes et elles recevront alors toutes les propriétés de leurs parents. Vous pourriez être surpris, mais il n'y a pas de classes en JavaScript. Il n'y a là que des objets. Et l'héritage est mis en œuvre différemment. Tous les objets peuvent être hérités directement d’autres objets. Pour ce faire, il suffit de spécifier l'objet souhaité comme prototype.

Quand est-il préférable de l’utiliser ?

Comme pour tous les langages, votre choix entre Java et JavaScript dépendra de nombreux facteurs. Par exemple, sur ce que vous voulez créer et de quelles ressources vous disposez pour cela. JavaScript est mieux adapté aux technologies Web, tandis que Java est idéal pour créer des programmes réguliers et tout autre chose.

Il est préférable de choisir Java si vous développez :

• Application Android ;
• Logiciels commerciaux ;
• Logiciels de calcul scientifique;
• Logiciel pour Grande analyse Données;
• Logiciels ou outils de sécurité à usage général ;
• Programmes serveur.

Il est préférable d'utiliser JavaScript dans les domaines suivants :

• Applications dynamiques à page unique (SPA) ;
• Applications fortes (Query, AngularJS, Backbone.js, Ember.js, ReactJS);
• Applications serveur (Node.js, MongoDB, Express.js, etc.) ;
• Applications mobiles (PhoneGap, Ract Native, etc.).

conclusions

Dans cet article, nous avons examiné en quoi Java diffère de Javascript. Comme vous pouvez le constater, il existe tout simplement de nombreuses différences, malgré le fait que les langues portent un nom similaire. A la question quoi meilleur Java ou javascript est difficile de répondre car les langages ont des usages très différents. J'espère que ces informations vous ont été utiles.

Pour conclure, une blague vidéo sur la confrontation entre Java et JavaScript basée sur Game of Thrones :