Exécution hybride interactive, code en direct et pré-rendu, WebAssembly interactif
L’exécution hybride est une technique avancée qui vous permet d’optimiser les documents interactifs en effectuant un pré-rendu des calculs lourds au moment de la construction, tout en maintenant l’interactivité côté client. Cette approche permet d’améliorer les temps de chargement des documents et la réactivité, tout en offrant des fonctionnalités dynamiques à l’utilisateur.
Les documents interactifs nécessitent souvent un équilibre entre performance et interactivité. En pré-calculant les données et les résultats pendant la construction du document (à l’aide de OJS sources de données) et en transmettant ensuite ces données à des cellules de code en direct exécutées dans le navigateur via WebAssembly, vous pouvez atteindre à la fois la vitesse et l’interactivité.
Principaux avantages:
Quarto Live prend en charge l’exportation de données en tant que sources de données OJS. Cela signifie que vous pouvez évaluer le code au moment de la création (par exemple, dans un bloc de code R) et exporter les résultats pour les utiliser ultérieurement dans des cellules interactives.
```{r}
# Prévisualiser l'ensemble de données ToothGrowth
head(ToothGrowth)
# Exporter ToothGrowth en tant que source de données OJS
ojs_define(ToothGrowth)
```
L'ensemble de données ToothGrowth est maintenant disponible en tant que variable OJS:
```{ojs}
ToothGrowth
```ToothGrowth est désormais accessible pour un traitement ultérieur côté client.# Prévisualiser l'ensemble de données ToothGrowth
head(ToothGrowth) len supp dose
1 4.2 VC 0.5
2 11.5 VC 0.5
3 7.3 VC 0.5
4 5.8 VC 0.5
5 6.4 VC 0.5
6 10.0 VC 0.5# Exporter ToothGrowth en tant que source de données OJS
ojs_define(ToothGrowth)L’ensemble de données ToothGrowth est maintenant disponible en tant que variable OJS:
ToothGrowthUne fois que vous disposez d’une source de données OJS, vous pouvez la réimporter dans un bloc de code R ou Python interactif à l’aide de l’option de cellule input. Cela vous permet de poursuivre le traitement ou la visualisation des données pré-rendues du côté client.
hybrid.qmd
```{webr}
#| input:
#| - ToothGrowth
# Filtrer les données de ToothGrowth pour des doses spécifiques et créer un graphique
data_filtered <- ToothGrowth |> dplyr::filter(dose %in% c(0.5, 2))
boxplot(len ~ dose, data = data_filtered)
head(data_filtered)
```Dans cet exemple, l’ensemble de données ToothGrowth pré-rendu est réimporté dans la cellule interactive R pour une analyse plus approfondie.
L’approche hybride permet également la communication entre différents moteurs WebAssembly (par exemple, entre R et Python). Les données traitées dans un moteur peuvent être transférées dans un autre, ce qui garantit la cohérence et une interactivité transparente.
```{webr}
#| edit: false
#| define:
#| - mpg
# Traiter et exporter un sous-ensemble du jeu de données mtcars
mpg <- mtcars |>
dplyr::select(mpg, hp) |>
dplyr::filter(mpg < 25)
```
```{pyodide}
#| edit: false
#| input:
#| - mpg
# Importez les données exportées dans Python et tracez-les
import matplotlib.pyplot as plt
import pandas as pd
df = pd.DataFrame(mpg)
plt.plot(df['mpg'], df['hp'], 'o')
plt.title("MPG vs HP")
plt.xlabel("Miles Per Gallon")
plt.ylabel("Horsepower")
plt.show()
```mpg est traité et exporté.mpg est importé et visualisé, ce qui démontre le transfert de données entre moteurs.Séparer les blocs statiques et interactifs:
Séparer clairement les calculs du temps de construction (qui peuvent être mis en cache) des cellules du code interactif en direct.
Utiliser efficacement les variables OJS:
Définir des sources de données OJS pour le traitement de données lourdes, puis importer ces sources dans des cellules interactives pour la visualisation et une analyse plus poussée.
Optimiser les performances:
Pré-rendez autant de contenu statique que possible et limitez les calculs en direct à ce qui est nécessaire à l’interactivité de l’utilisateur.
Tester dans plusieurs environnements:
Vérifiez que les données passent correctement entre les blocs R et Python, et que les éléments pré-rendus et en direct fonctionnent comme prévu.
L’exécution hybride vous permet d’exploiter le meilleur des deux mondes : des sorties statiques pré-rendues pour les calculs lourds et des éléments interactifs en direct pour l’exploration dynamique. En transférant des données par le biais de variables OJS et en passant des données entre différents moteurs WebAssembly, vous pouvez créer des documents interactifs efficaces et très réactifs. Expérimentez ces techniques pour créer un contenu interactif riche, performant et facilement évolutif.
Voici d’autres articles de la même catégorie pour vous aider à approfondir le sujet.
@online{kassambara2025,
author = {Kassambara, Alboukadel},
title = {Exécution hybride : Mélange de contenu pré-rendu et en
direct},
date = {2025-03-21},
url = {https://www.datanovia.com/fr/learn/interactive/advanced/hybrid-execution.html},
langid = {fr}
}