TypeScript au quotidien
Les classes, génériques, unions, décorateurs, modules, async/await et fonctionnalités modernes du système de types sont pris en charge dans les flux SharpTS.
Un interpréteur TypeScript et compilateur AOT pour .NET
Exécutez-le comme un script pour un retour immédiat, ou compilez-le en assembly .NET natif — avec un accès complet à l'écosystème .NET.
curl -fsSL https://sharpts.dev/setup.sh | shirm https://sharpts.dev/setup.ps1 | iex// Exécutez du TypeScript directement sur .NET
interface Greeter {
greet(name: string): string;
}
class WelcomeBot implements Greeter {
constructor(private prefix: string) {}
greet(name: string): string {
return `${this.prefix}, ${name}! Welcome to SharpTS.`;
}
}
const bot = new WelcomeBot("Hello");
console.log(bot.greet("Developer"));
// → Hello, Developer! Welcome to SharpTS.Écrivez du TypeScript qui s'exécute sur le runtime .NET — interprété pour une itération rapide, ou compilé en assemblys .NET natifs.
Pointez SharpTS vers un fichier .ts et il s'exécute — sans étape de build ni configuration. Idéal pour les scripts, l'automatisation et l'exploration d'idées dans le REPL.
Compilation anticipée vers un véritable assembly .NET — une DLL, un exécutable autonome ou un paquet NuGet — s'exécutant à la vitesse native du CLR.
Appelez des bibliothèques .NET depuis TypeScript avec @DotNetType, et utilisez votre TypeScript compilé depuis C#. Réutilisez la BCL, les paquets NuGet et le code que vous avez déjà.
Utilisez le TypeScript que vous connaissez — génériques, classes, décorateurs, async, modules et plus encore — avec une vérification des types avant l’exécution. Consultez l’aperçu pratique de compatibilité ci-dessous.
Ajoutez le SharpTS.Sdk à un projet .NET et dotnet build compile votre TypeScript aux côtés de votre C# — même chaîne d'outils, même résultat.
Un serveur de langage apporte l'autocomplétion, la vérification de types et le « aller à la définition » à VS Code et Visual Studio.
Du vrai TypeScript exécuté sur le runtime .NET
const greeting: string = "Hello from SharpTS!";
const version: number = 1.0;
console.log(`${greeting} v${version}`);
const languages = ["TypeScript", "C#", ".NET"];
languages.forEach(lang => console.log(` ✓ ${lang}`));Hello from SharpTS! v1 ✓ TypeScript ✓ C# ✓ .NET
interface Comparable<T> { compareTo(other: T): number; }
class Temperature implements Comparable<Temperature> {
constructor(private celsius: number) {}
get fahrenheit(): number { return this.celsius * 9 / 5 + 32; }
compareTo(other: Temperature): number { return this.celsius - other.celsius; }
toString(): string { return `${this.celsius}°C (${this.fahrenheit}°F)`; }
}
const temps = [new Temperature(100), new Temperature(0), new Temperature(37)];
temps.sort((a, b) => a.compareTo(b));
temps.forEach(t => console.log(t.toString()));0°C (32°F) 37°C (98.6°F) 100°C (212°F)
async function delay(ms: number): Promise<string> { return `Done after ${ms}ms`; }
async function main() {
console.log(await delay(100));
const all = await Promise.all([delay(50), delay(100), delay(150)]);
all.forEach(result => console.log(result));
}
main();Done after 100ms Done after 50ms Done after 100ms Done after 150ms
const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const result = data.filter(n => n % 2 === 0).map(n => n ** 2).reduce((sum, n) => sum + n, 0);
console.log(`Sum of squares of evens: ${result}`);
const [first, second, ...rest] = data;
console.log(`First: ${first}, Second: ${second}`);
console.log(`Rest: [${rest.join(", ")}]`);Sum of squares of evens: 220 First: 1, Second: 2 Rest: [3, 4, 5, 6, 7, 8, 9, 10]
console.log(`PI = ${Math.PI}`);
console.log(`E = ${Math.E}`);
console.log(`sqrt(144) = ${Math.sqrt(144)}`);
const now = new Date("2026-03-02T12:00:00.000Z");
console.log(`ISO: ${now.toISOString()}`);
const obj = { name: "SharpTS", nums: [1, 2, 3] };
console.log(`JSON: ${JSON.stringify(obj)}`);PI = 3.141592653589793
E = 2.718281828459045
sqrt(144) = 12
ISO: 2026-03-02T12:00:00.000Z
JSON: {"name":"SharpTS","nums":[1,2,3]}// Full CLI interop (the public playground intentionally disables module loading)
@DotNetType("System.Text.StringBuilder")
declare class StringBuilder {
constructor();
append(value: string): StringBuilder;
toString(): string;
}
@DotNetType("System.TimeSpan")
declare class TimeSpan {
static fromHours(value: number): TimeSpan;
readonly totalMinutes: number;
}
const sb = new StringBuilder();
sb.append("1.5 hours = ");
sb.append(`${TimeSpan.fromHours(1.5).totalMinutes} minutes`);
console.log(sb.toString());1.5 hours = 90 minutes
Des situations concrètes où TypeScript sur .NET l'emporte sur Node — ou sur C#.
Écrivez des scripts de build, des outils de dev et de l'automatisation ponctuelle en TypeScript avec toute la BCL à disposition — sur des machines qui ont déjà le SDK .NET et aucune chaîne d'outils Node. Pas de package.json, pas d'étape de build : pointez sharpts vers le fichier.
sharpts rotate-logs.tsCompilez un module TypeScript en véritable assembly et publiez-le comme paquet NuGet versionné. Avec un assembly de référence, les appelants C# instancient vos classes et appellent vos méthodes de façon entièrement typée.
sharpts --compile pricing.ts --ref-asm
sharpts --compile pricing.ts --packLaissez vos collègues venus de TypeScript contribuer dans le langage qu'ils maîtrisent le mieux. Avec SharpTS.Sdk, leurs fichiers .ts sont compilés dans le même dotnet build que les projets C# qui les entourent — une seule chaîne d'outils, un seul pipeline CI.
<Project Sdk="SharpTS.Sdk/1.0.0">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<SharpTSEntryPoint>src/main.ts</SharpTSEntryPoint>
</PropertyGroup>
</Project>Compilez vers un exécutable autonome unique qui s'exécute sans installation de runtime séparée — pas de Node sur la machine cible, pas de dossier node_modules livré à côté de votre outil.
sharpts --compile tool.ts -t exe
./toolUn pipeline multi-étapes, de la source à l'exécution
Écrivez du TypeScript et exécutez-le sur .NET — directement dans votre navigateur
Un aperçu pratique des fonctionnalités TypeScript et d’exécution disponibles aujourd’hui. Pour des résultats mesurés, explorez la conformité.
Les classes, génériques, unions, décorateurs, modules, async/await et fonctionnalités modernes du système de types sont pris en charge dans les flux SharpTS.
Les API courantes d’Array, String, collections, Promise, Date, RegExp, JSON, Symbol et tableaux typés sont disponibles.
Les imports nus et les champs exports/imports des paquets peuvent être résolus, mais les paquets dépendent toujours d’une syntaxe et d’API d’exécution compatibles avec SharpTS. Les paquets livrant leur source TypeScript sont les mieux adaptés.
Proxy et WeakRef ne sont pas implémentés. Les résultats de l’interpréteur et de l’AOT peuvent aussi différer sur certains cas limites de la spécification.
Les questions qui viennent en premier — avec des réponses directes.
tsc vérifie les types de votre code et émet du JavaScript qu'un moteur comme Node exécute. SharpTS ne produit jamais de JavaScript : il vérifie les types du même TypeScript, puis l'exécute directement ou le compile en assembly .NET. Il n'y a aucun Node dans la chaîne. Le script d'installation utilise le SDK .NET lorsqu'il est disponible, sinon il installe une version autonome.
Ces projets exécutent du JavaScript brut, non typé, dans un hôte .NET — très bien pour de petits scripts embarqués. SharpTS exécute TypeScript lui-même, vérifié avant l'exécution, et ajoute ce qu'un moteur JS embarqué ne peut pas offrir : la compilation anticipée vers IL, l'empaquetage NuGet et l'interop typée dans les deux sens entre TypeScript et C#.
Partiellement. Les imports nus se résolvent via node_modules, et les modes de résolution pris en charge peuvent appliquer les champs exports/imports et les cibles conditionnelles des paquets. Un paquet peut néanmoins échouer s’il dépend d’une syntaxe non prise en charge, d’extensions natives, de globales du navigateur ou d’API d’exécution manquantes. Les paquets livrant leur source TypeScript sont les mieux adaptés.
Voir le suivi de compatibilité Node.js →Chaque mode répond différemment. L'interpréteur parcourt l'arbre syntaxique et vise un démarrage instantané — idéal pour les scripts et le REPL, pas pour le calcul intensif. Le mode compilé émet de l'IL que le CLR compile à la volée comme n'importe quel assembly C# : il s'exécute comme du code .NET natif. Dans les deux modes, les types sont vérifiés en amont puis effacés — ils ne coûtent rien à l'exécution.
C’est un projet jeune, sous licence MIT et en développement actif. L’aperçu de compatibilité ci-dessus résume les capacités courantes, la conformité mesurée en publie les preuves détaillées et STATUS.md suit les manques d’implémentation.
Suivre l'avancement dans STATUS.md →Opérationnel en trois étapes
Exécutez le script d'installation pour installer la version de SharpTS adaptée à cette machine
curl -fsSL https://sharpts.dev/setup.sh | shirm https://sharpts.dev/setup.ps1 | iexCréez un fichier TypeScript
interface Config {
name: string;
debug: boolean;
}
const config: Config = { name: "MyApp", debug: true };
console.log(`Starting ${config.name}...`);Interprétez directement ou compilez vers un assembly .NET
# Interpréter (démarrage instantané)
sharpts hello.ts
# Compiler vers un assembly .NET
sharpts --compile hello.ts -o hello