Résumé de l'appel des méthodes js dans Kotlin

Cet article présente principalement les informations pertinentes sur l'explication détaillée de l'instance d'appel de la méthode JavaScript dans le langage Kotlin. Les amis dans le besoin peuvent se référer au

Le. explication détaillée de l'instance de la méthode d'appel du JavaScript dans le langage Kotlin

Kotlin a été conçu pour interopérer facilement avec la plateforme Java. Il traite les classes Java comme des classes Kotlin, et Java traite les classes Kotlin comme des classes Java. Cependant, JavaScript est un langage typé dynamiquement, ce qui signifie qu'il ne vérifie pas les types au moment de la compilation. Vous pouvez communiquer librement avec JavaScript dans Kotlin via la saisie dynamique, mais si vous souhaitez bénéficier de toute la puissance du système de types Kotlin, vous pouvez créer des fichiers d'en-tête Kotlin pour vos bibliothèques JavaScript.

JavaScript en ligne

Vous pouvez intégrer du code JavaScript dans le code Kotlin à l'aide de la fonction js("..."). Par exemple :

fun jsTypeOf(o: Any): String {
 return js("typeof o")
}

Les paramètres de js doivent être des constantes string. Par conséquent, le code suivant est incorrect :

fun jsTypeOf(o: Any): String {
 return js(getTypeof() + " o") // 此处报错
}
fun getTypeof() = "typeof"

modificateur externe

indique à Kotlin qu'une certaine déclaration est utilisée. Écrit dans JavaScript pur, vous devez le marquer avec le modificateur externe. Lorsque le compilateur voit une telle déclaration, il suppose que l'implémentation de la classe, de la fonction ou de la propriété correspondante a été fournie par le développeur et ne tente donc pas de générer du code JavaScript à partir de la déclaration. Cela signifie que vous devez omettre le corps du contenu de la déclaration externe. Par exemple :

external fun alert(message: Any?): Unit

external class Node {
 val firstChild: Node

 fun append(child: Node): Node

 fun removeChild(child: Node): Node

 // 等等
}
external val window: Window

Veuillez noter que les déclarations imbriquées hériteront du modificateur externe, c'est-à-dire que dans la classe Node, nous ne plaçons pas external avant les fonctions et propriétés membres .

Le modificateur externe n'est autorisé que dans les déclarations au niveau du package. Vous ne pouvez pas déclarer un membre externe d'une classe non externe.

Déclarer (statique) les membres d'une classe

En JavaScript, vous pouvez définir des membres sur le prototype ou sur la classe elle-même . C'est-à-dire :

function MyClass() {
}
MyClass.sharedMember = function() { /* 实现 */ };
MyClass.prototype.ownMember = function() { /* 实现 */ };

Il n'existe pas de syntaxe de ce type dans Kotlin. Cependant, dans Kotlin, nous avons des objets compagnons. Kotlin traite les objets compagnons de la classe externe d'une manière particulière : au lieu d'attendre un objet, il suppose que les membres de l'objet compagnon sont membres de la classe elle-même. Pour décrire MyClass à partir de l'exemple ci-dessus, vous pouvez écrire :

external class MyClass {
 companion object {
  fun sharedMember()
 }

 fun ownMember()
}

Déclarer les paramètres facultatifs

une fonction externe peut avoir paramètres facultatifs. La manière dont l'implémentation JavaScript calcule réellement les valeurs par défaut de ces paramètres est inconnue de Kotlin, il n'est donc pas possible de déclarer ces paramètres en utilisant la syntaxe habituelle de Kotlin. Vous devez utiliser la syntaxe suivante :

external fun myFunWithOptionalArgs(x: Int,
 y: String = definedExternally,
 z: Long = definedExternally)

Cela signifie que vous pouvez appeler myFunWithOptionalArgs avec un paramètre obligatoire et deux paramètres facultatifs (leurs valeurs par défaut sont déterminées par du JavaScript code).

Extension des classes JavaScript

Vous pouvez facilement étendre les classes JavaScript car ce sont des classes Kotlin. Définissez simplement une classe externe et étendez-la avec des classes non externes. Par exemple :

external open class HTMLElement : Element() {
 /* 成员 */
}

class CustomElement : HTMLElement() {
 fun foo() {
  alert("bar")
 }
}

Il existe certaines restrictions :

Lorsqu'une fonction d'une classe de base externe est signée surchargée, il ne peut pas le remplacer dans les classes dérivées.

ne peut pas remplacer une fonction qui utilise des paramètres par défaut.

Veuillez noter que vous ne pouvez pas étendre une classe non externe avec une classe externe.

interface externe

JavaScript n'a pas de notion d'interface. Lorsqu'une fonction s'attend à ce que ses arguments prennent en charge les méthodes foo et bar, transmettez simplement l'objet qui possède réellement ces méthodes. Pour Kotlin typé statiquement, vous pouvez exprimer cela à l'aide d'interfaces, par exemple :

external interface HasFooAndBar {
 fun foo()

 fun bar()
}

external fun myFunction(p: HasFooAndBar)

Un autre cas d'utilisation des interfaces externes consiste à décrire des objets de paramètres. Par exemple :

external interface JQueryAjaxSettings {
 var async: Boolean

 var cache: Boolean

 var complete: (JQueryXHR, String) -> Unit

 // 等等
}

fun JQueryAjaxSettings(): JQueryAjaxSettings = js("{}")

external class JQuery {
 companion object {
  fun get(settings: JQueryAjaxSettings): JQueryXHR
 }
}

fun sendQuery() {
 JQuery.get(JQueryAjaxSettings().apply {
  complete = { (xhr, data) ->
   window.alert("Request complete")
  }
 })
}

Les interfaces externes ont certaines restrictions :

Elles ne peuvent pas être utilisées sur le côté droit d'un ordinateur. vérifier.
car la conversion vers une interface externe réussit toujours (et produit un avertissement au moment de la compilation).
Ils ne peuvent pas être transmis en tant que paramètres de type réifié.
Ils ne peuvent pas être utilisés dans une expression littérale d'une classe (c'est-à-dire I::class).

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!