10 langages de script JavaScript intéressants

Nous savons tous que JavaScript n'est pas le meilleur langage pour toutes les tâches, et lorsqu'il s'agit d'applications complexes, il peut ne pas convenir. Pour éviter ce problème, plusieurs nouveaux langages et variantes de langages existants ont été créés, qui génèrent tous du code pouvant s'exécuter dans le navigateur sans avoir à écrire de code JavaScript ni prendre en compte les limitations du langage.

Dart est un langage orienté objet classique, où tout est un objet et tout objet est une instance d'une classe (les objets peuvent également agir comme des fonctions). Il est spécialement conçu pour créer des applications pour les navigateurs, les serveurs et les appareils mobiles. Il est géré par Google et constitue le langage qui pilote l'interface utilisateur de nouvelle génération pour AdWords, le produit le plus important générant des revenus pour Google, ce qui en soi témoigne de sa puissance à grande échelle.

Le langage peut être traduit en JavaScript pour être utilisé dans le navigateur, ou interprété et exécuté directement par la VM Dart, qui vous permet également de créer des applications serveur. Des applications mobiles peuvent être créées à l'aide du SDK Flutter.

Les applications complexes nécessitent également un ensemble mature de bibliothèques et de fonctionnalités de langage conçues spécifiquement pour la tâche, et Dart les inclut toutes. Un exemple de bibliothèque populaire est AngularDart, la version Dart d'Angular.

Il vous permet d'écrire du code sécurisé sans être trop intrusif ; vous pouvez écrire des types, mais ce n'est pas nécessaire car ils peuvent être déduits. Cela permet de créer des prototypes rapides sans avoir à trop réfléchir aux détails, mais une fois votre prototype fonctionnel, vous pouvez ajouter des types pour le rendre plus robuste.

Concernant la programmation simultanée dans les machines virtuelles, Dart utilise ce que l'on appelle des Isolates avec leurs propres tas de mémoire, au lieu de threads de mémoire partagée (Dart est monothread), en utilisant des messages pour implémenter la communication . Dans le navigateur, cet événement est légèrement différent : au lieu de créer de nouveaux isolats, vous créez de nouveaux Workers .

// Example extracted from dartlang.org

import 'dart:async';
import 'dart:math' show Random;

main() async {
  print('Compute π using the Monte Carlo method.');
  await for (var estimate in computePi()) {
    print('π ≅ $estimate');
  }
}

/// Generates a stream of increasingly accurate estimates of π.
Stream<double> computePi({int batch: 1000000}) async* {
  var total = 0;
  var count = 0;
  while (true) {
    var points = generateRandom().take(batch);
    var inside = points.where((p) => p.isInsideUnitCircle);
    total += batch;
    count += inside.length;
    var ratio = count / total;
    // Area of a circle is A = π⋅r², therefore π = A/r².
    // So, when given random points with x ∈ <0,1>,
    // y ∈ <0,1>, the ratio of those inside a unit circle
    // should approach π / 4. Therefore, the value of π
    // should be:
    yield ratio * 4;
  }
}

Iterable<Point> generateRandom([int seed]) sync* {
  final random = new Random(seed);
  while (true) {
    yield new Point(random.nextDouble(), random.nextDouble());
  }
}

class Point {
  final double x, y;
  const Point(this.x, this.y);
  bool get isInsideUnitCircle => x * x + y * y <= 1;
}

Commencez avec Dart

TypeScript

TypeScript est un sur-ensemble de JavaScript ; un programme JavaScript valide est également un programme valide ; Programme TypeScript , mais ce dernier ajoute un typage statique. Son compilateur peut également servir de traducteur d'ES2015+ vers l'implémentation actuelle, afin que vous bénéficiiez toujours des dernières fonctionnalités.

Contrairement à de nombreux autres langages, TypeScript conserve intact l'esprit de JavaScript et ajoute uniquement des fonctionnalités pour rendre votre code plus fiable. Il s'agit d'annotations de type, ainsi que d'autres fonctionnalités liées au type, qui rendent l'écriture de JavaScript plus agréable, grâce à l'activation d'outils spécialisés tels que les analyseurs statiques pour faciliter le processus de refactorisation. De plus, l'ajout de types améliore l'interface entre les différents composants de l'application.

L'inférence de type est prise en charge, vous n'avez donc pas besoin d'écrire tous les types depuis le début. Vous pouvez écrire des solutions rapides, puis ajouter tous les types pour avoir confiance en votre code.

TypeScript prend également en charge les types avancés tels que les types d'intersection, les types d'union, les alias de type, les unions discriminées et les gardes de type. Vous pouvez afficher tous ces types sur la page Types avancés du site de documentation TypeScript.

Si vous utilisez React, vous pouvez également prendre en charge JSX en ajoutant des types React.

class Person {
    private name: string;
    private age: number;
    private salary: number;

    constructor(name: string, age: number, salary: number) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    toString(): string {
        return `${this.name} (${this.age}) (${this.salary})`;
    }
}

Elm est un langage de programmation purement fonctionnel qui compile en JS, HTML et CSS. Vous pouvez créer un site entier en utilisant uniquement Elm. Cela en fait une excellente alternative aux frameworks JavaScript comme React. Les applications créées avec lui utilisent automatiquement la bibliothèque virtuelle DOM, ce qui les rend très rapides. L'un de ses grands avantages est l'architecture intégrée, qui vous fait oublier le flux de données et vous concentrer sur la déclaration et la logique des données.

Dans Elm, toutes les fonctions sont pures, ce qui signifie qu'elles renverront toujours la même sortie pour une entrée donnée. Ils ne peuvent rien faire d’autre sauf si vous le spécifiez. Par exemple, pour accéder à une API distante, vous créeriez une fonction commande (commande) pour communiquer avec le monde extérieur, et un abonnement (abonnement) pour écouter les réponses. Un autre point de pureté est que les valeurs sont immuables ; lorsque vous avez besoin de quelque chose, vous créez de nouvelles valeurs plutôt que de modifier les anciennes.

L'adoption d'Elm peut être incrémentielle ; les ports peuvent être utilisés pour communiquer avec JavaScript et d'autres bibliothèques. Bien qu'Elm n'ait pas encore atteint la version 1, il est utilisé dans des applications complexes et volumineuses, ce qui en fait une solution viable pour les applications complexes.

L'une des fonctionnalités les plus attrayantes d'Elm est le compilateur convivial pour les débutants qui, au lieu de générer des messages difficiles à lire, génère du code qui peut vous aider à corriger votre code. Si vous apprenez le langage, le compilateur lui-même peut être d'une grande aide.

module Main exposing (..)

import Html exposing (..)


-- MAIN


main : Program Never Model Msg
main =
    Html.program
        { init = init
        , update = update
        , view = view
        , subscriptions = subscriptions
        }



-- INIT


type alias Model = String


init : ( Model, Cmd Msg )
init = ( "Hello World!", Cmd.none )


-- UPDATE


type Msg
    = DoNothing


update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        DoNothing ->
            ( model, Cmd.none )


-- VIEW


view : Model -> Html Msg
view model =
    p [] [text model]


-- SUBSCRIPTIONS


subscriptions : Model -> Sub Msg
subscriptions model =
    Sub.none

Commencez à utiliser Elm

PureScript

PureScript est un langage de programmation purement fonctionnel et fortement typé créé par Phil Freeman. Il vise à offrir une forte compatibilité avec les bibliothèques JavaScript disponibles, similaire dans son esprit à Haskell, mais en gardant le cœur de JavaScript.

PureScript 的一个强项是它的极简主义。它不包括在其他语言中被认为是必需的功能的任何库。例如，不是编译器本身包含生成器和 promises，而是你可以使用特定的库来完成任务。你可以为所需功能选择想要的实现，这样可以在使用 PureScript 时实现高效和个性化的体验，同时保持生成的代码尽可能小。

其编译器的另一个显著特征就是能够在保持与 JavaScript 的兼容性的同时， 用库和工具生成整洁和可读的代码。

像其他语言一样，PureScript 有自己的构建工具叫做 Pulp，可以与 Gulp 进行比较， 但是用于以这种语言编写的项目。

关于类型系统，与 Elm不同，即另一种 ML 式的语言，PureScript 支持高级类型的功能，如取自 Haskell 的 higher-kinded types（高级类类型） 以及 type classes（类型类）， 从而允许创建复杂的抽象。

module Main where

import Prelude
import Data.Foldable (fold)
import TryPureScript

main =
    render $ fold
      [ h1 (text "Try PureScript!")
      , p (text "Try out the examples below, or create your own!")
      , h2 (text "Examples")
      , list (map fromExample examples)
      ]
  where
    fromExample { title, gist } =
      link ("?gist=" <> gist) (text title)

    examples =
      [ { title: "Algebraic Data Types"
        , gist: "37c3c97f47a43f20c548"
        }
      , { title: "Loops"
        , gist: "cfdabdcd085d4ac3dc46"
        }
      , { title: "Operators"
        , gist: "3044550f29a7c5d3d0d0"
        }
      ]

开始使用 PureScript

CoffeeScript

CoffeeScript 是一种语言，旨在公开 JavaScript 的良好部分，同时提供更整洁的语法并保留语义。虽然该语言的流行度近年来一直在减弱，但它正在改变方向，现在正在获得一个新的主要版本，为 ES2015+ 的功能提供支持。

你用 CoffeeScript 编写的代码被直接翻译为可读的 JavaScript 代码，并保持与现有库的兼容性。从版本 2 开始，编译器将产生与最新版本的 ECMAScript 兼容的代码。例如，每次你使用一个类，你就获得一个 JavaScript 类。另外，如果你使用 React，也有好消息： JSX 与 CoffeeScript 兼容。

以上内容介绍了10个有趣的语言，这些语言都可以转换成JavaScript代码在浏览器中执行，也可以在Node.js这样的平台上执行。希望能帮助到大家。

相关推荐：

如何用php传递数组给js脚本

JavaScript实现浏览器用户代理检测脚本的方法详解

JavaScript中关于表单脚本的实用技巧

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!