10 interessante JavaScript-Skriptsprachen

Wir alle wissen, dass JavaScript nicht für alle Aufgaben die beste Sprache ist und für komplexe Anwendungen möglicherweise nicht geeignet ist. Um dieses Problem zu vermeiden, wurden mehrere neue Sprachen und Variationen bestehender Sprachen erstellt, die alle Code generieren, der im Browser ausgeführt werden kann, ohne dass JavaScript-Code geschrieben werden muss oder die Einschränkungen der Sprache berücksichtigt werden müssen.

Dart ist eine klassische objektorientierte Sprache, in der alles ein Objekt ist und jedes Objekt eine Instanz einer Klasse ist (Objekte können auch als Funktionen fungieren). Es wurde speziell für die Erstellung von Anwendungen für Browser, Server und mobile Geräte entwickelt. Sie wird von Google gepflegt und ist die Sprache, die die Benutzeroberfläche der nächsten Generation für AdWords antreibt, das wichtigste Produkt, das Google Einnahmen generiert, was an sich schon ein Beweis für seine große Leistungsfähigkeit ist.

Die Sprache kann zur Verwendung im Browser in JavaScript übersetzt oder direkt von der Dart-VM interpretiert und ausgeführt werden, wodurch Sie auch Serveranwendungen erstellen können. Mobile Apps können mit dem Flutter SDK erstellt werden.

Komplexe Anwendungen erfordern auch einen ausgereiften Satz von Bibliotheken und Sprachfunktionen, die speziell für die Aufgabe entwickelt wurden, und Dart umfasst alle davon. Ein Beispiel für eine beliebte Bibliothek ist AngularDart, die Dart-Version von Angular.

Es ermöglicht Ihnen, typsicheren Code zu schreiben, ohne zu aufdringlich zu sein. Sie können Typen schreiben, müssen dies aber nicht, da sie abgeleitet werden können. Dies ermöglicht die schnelle Erstellung von Prototypen, ohne sich über die Details Gedanken machen zu müssen. Sobald Ihr Prototyp jedoch funktioniert, können Sie Typen hinzufügen, um ihn robuster zu machen.

In Bezug auf die gleichzeitige Programmierung in virtuellen Maschinen verwendet Dart sogenannte Isolate zusammen mit ihren eigenen Speicher-Heaps anstelle von Shared-Memory-Threads (Dart ist Single-Threaded) und nutzt Nachrichten, um die Kommunikation zu implementieren . Im Browser ist dieses Ereignis etwas anders: Anstatt neue Isolate zu erstellen, erstellen Sie neue Worker .

// 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;
}

Erste Schritte mit Dart

TypeScript

TypeScript ist eine Obermenge von JavaScript TypeScript-Programm, aber letzteres fügt statische Typisierung hinzu. Sein Compiler kann auch als Übersetzer von ES2015+ zur aktuellen Implementierung fungieren, sodass Sie immer die neuesten Funktionen erhalten.

Im Gegensatz zu vielen anderen Sprachen behält TypeScript den Geist von JavaScript bei und fügt nur Funktionen hinzu, um Ihren Code zuverlässiger zu machen. Hierbei handelt es sich um Typanmerkungen zusammen mit anderen typbezogenen Funktionen, die das Schreiben von JavaScript angenehmer machen, da spezielle Tools wie statische Analysatoren den Refactoring-Prozess unterstützen. Darüber hinaus verbessert das Hinzufügen von Typen die Schnittstelle zwischen verschiedenen Komponenten der Anwendung.

Typinferenz wird unterstützt, sodass Sie nicht alle Typen von Anfang an schreiben müssen. Sie können schnelle Lösungen schreiben und dann alle Typen hinzufügen, um Vertrauen in Ihren Code zu gewinnen.

TypeScript unterstützt auch erweiterte Typen wie Schnittmengentypen, Union-Typen, Typaliase, diskriminierte Unions und Typwächter. Sie können alle diese Typen auf der Seite „Erweiterte Typen“ der TypeScript-Dokumentationsseite anzeigen.

Wenn Sie React verwenden, können Sie JSX auch unterstützen, indem Sie React-Typen hinzufügen.

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 ist eine rein funktionale Programmiersprache, die zu JS, HTML und CSS kompiliert. Sie können eine ganze Site nur mit Elm erstellen. Dies macht es zu einer großartigen Alternative zu JavaScript-Frameworks wie React. Damit erstellte Anwendungen nutzen automatisch die virtuelle DOM-Bibliothek und sind dadurch sehr schnell. Einer der großen Vorteile ist die integrierte Architektur, die es Ihnen ermöglicht, den Datenfluss zu vergessen und sich auf die Datendeklaration und Logik zu konzentrieren.

In Elm sind alle Funktionen rein, was bedeutet, dass sie für eine bestimmte Eingabe immer die gleiche Ausgabe zurückgeben. Sie können nichts anderes tun, es sei denn, Sie geben es an. Um beispielsweise auf eine Remote-API zuzugreifen, würden Sie eine Befehlsfunktion (Befehlsfunktion) erstellen, um mit der Außenwelt zu kommunizieren, und ein Abonnement (Abonnement), um auf Antworten zu warten. Ein weiterer Punkt der Reinheit ist, dass Werte unveränderlich sind; wenn man etwas braucht, schafft man neue Werte, anstatt alte zu modifizieren.

Die Einführung von Elm kann inkrementell erfolgen; Ports können für die Kommunikation mit JavaScript und anderen Bibliotheken verwendet werden. Obwohl Elm noch nicht Version 1 erreicht hat, wird es in komplexen und großen Anwendungen eingesetzt, was es zu einer praktikablen Lösung für komplexe Anwendungen macht.

Eine der attraktivsten Funktionen von Elm ist der anfängerfreundliche Compiler, der, anstatt schwer lesbare Nachrichten zu generieren, Code generiert, der Ihnen bei der Korrektur Ihres Codes helfen kann. Wenn Sie die Sprache lernen, kann der Compiler selbst eine große Hilfe sein.

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

Beginnen Sie mit der Verwendung von Elm

PureScript

PureScript ist eine rein funktionale und stark typisierte Programmiersprache, die von Phil Freeman entwickelt wurde. Ziel ist es, eine starke Kompatibilität mit verfügbaren JavaScript-Bibliotheken bereitzustellen, die im Geiste Haskell ähneln, aber den Kern von JavaScript beibehalten.

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中关于表单脚本的实用技巧

Das obige ist der detaillierte Inhalt von10 interessante JavaScript-Skriptsprachen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!