Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Linked List
.NET AIDE

C# Linked List (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Une liste chaînée est une structure de données linéaire composée d'une série de nœuds, qui peuvent également être appelés éléments. Contrairement aux tableaux, où les éléments/nœuds sont stockés dans des emplacements de mémoire contigus, les listes chaînées utilisent l'allocation dynamique de mémoire, permettant aux éléments/nœuds d'être dispersés dans la mémoire.

Dans sa forme la plus simple, les « listes chaînées » se composent de nœuds reliés linéairement. Chaque nœud contient deux parties principales :

  1. Données : Charge utile stockée dans le nœud. Cela peut être de n'importe quel type de données selon l'implémentation, tels que des entiers, des chaînes, des objets, etc.
  2. Pointeur suivant : Une référence (ou pointeur) vers le nœud suivant dans la séquence. Ce pointeur indique l'emplacement mémoire du nœud suivant en avant dans la liste chaînée.

Le dernier nœud d'une liste chaînée pointe généralement vers une référence nulle, indiquant la fin de la liste.

In this article, we will look in detail at the Linked list in C# and also explore the IronPDF library, a PDF generation tool from Iron Software.

Types de listes chaînées

1. Liste chaînée simplement

Une liste chaînée simplement a un nœud avec une seule référence, pointant généralement vers le nœud suivant dans la séquence. Le parcours de la liste est limité à un mouvement dans une seule direction, typiquement de la tête (le nœud initial) à la queue (le nœud final).

2. Liste chaînée doublement

Dans une liste chaînée doublement, chaque nœud contient deux références : l'une pointant vers le nœud suivant et l'autre pointant vers le nœud précédent dans la séquence. Ce lien bidirectionnel permet un parcours dans les deux directions, avant et arrière.

3. Liste chaînée circulaire

Dans une liste chaînée circulaire, le dernier nœud renvoie au premier nœud, formant une structure circulaire. Ce type de liste chaînée peut être mis en œuvre en utilisant soit des nœuds simplement chaînés soit doublement chaînés.

Opérations de base sur les listes chaînées

  1. Insertion : Ajout d'un nouveau nœud à la liste à un emplacement spécifique, comme le début, la fin ou le milieu.
  2. Suppression : Suppression d'un nœud objet spécifié de la liste, et ajustement des pointeurs des nœuds voisins en conséquence.
  3. Parcours : Itération dans la liste pour accéder ou manipuler les données de chaque nœud.
  4. Recherche : Recherche d'un nœud spécifique dans la liste en fonction de la valeur de données spécifiée.

Liste chaînée en C#

En C#, vous pouvez implémenter une liste chaînée en utilisant la classe LinkedList de l'espace de noms System.Collections.Generic. Voici un exemple de toutes les opérations de base :

using System;
using System.Collections.Generic;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            // Create a new linked list of integers
            LinkedList<int> linkedList = new LinkedList<int>();

            // Add elements to the linked list
            linkedList.AddLast(10);
            linkedList.AddLast(20);
            linkedList.AddLast(30);
            linkedList.AddLast(40);

            // Traverse and print the elements of the linked list
            Console.WriteLine("Traverse Linked List elements:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Display number of linked list elements
            Console.WriteLine($"Number of Linked List elements: {linkedList.Count}");

            // Find/Search for an element in the linked list
            Console.WriteLine("\nFind/Search Element Linked List elements: 30");
            var foundNode = linkedList.Find(30);

            if (foundNode != null)
            {
                Console.WriteLine(
                    $"Found Value: {foundNode.Value}, " +
                    $"Next Element: {(foundNode.Next != null ? foundNode.Next.Value.ToString() : "null")}, " +
                    $"Previous Element: {(foundNode.Previous != null ? foundNode.Previous.Value.ToString() : "null")}"
                );
            }

            // Insert an element at a specified node
            LinkedListNode<int> current = linkedList.Find(20);
            if (current != null)
            {
                linkedList.AddAfter(current, 25);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
            Console.WriteLine("\nLinked List elements after insertion:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Remove an existing node from the linked list
            linkedList.Remove(30);

            Console.WriteLine("\nLinked List elements after removal:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
        }
    }
}
using System;
using System.Collections.Generic;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            // Create a new linked list of integers
            LinkedList<int> linkedList = new LinkedList<int>();

            // Add elements to the linked list
            linkedList.AddLast(10);
            linkedList.AddLast(20);
            linkedList.AddLast(30);
            linkedList.AddLast(40);

            // Traverse and print the elements of the linked list
            Console.WriteLine("Traverse Linked List elements:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Display number of linked list elements
            Console.WriteLine($"Number of Linked List elements: {linkedList.Count}");

            // Find/Search for an element in the linked list
            Console.WriteLine("\nFind/Search Element Linked List elements: 30");
            var foundNode = linkedList.Find(30);

            if (foundNode != null)
            {
                Console.WriteLine(
                    $"Found Value: {foundNode.Value}, " +
                    $"Next Element: {(foundNode.Next != null ? foundNode.Next.Value.ToString() : "null")}, " +
                    $"Previous Element: {(foundNode.Previous != null ? foundNode.Previous.Value.ToString() : "null")}"
                );
            }

            // Insert an element at a specified node
            LinkedListNode<int> current = linkedList.Find(20);
            if (current != null)
            {
                linkedList.AddAfter(current, 25);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
            Console.WriteLine("\nLinked List elements after insertion:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            // Remove an existing node from the linked list
            linkedList.Remove(30);

            Console.WriteLine("\nLinked List elements after removal:");
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
        }
    }
}
Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic

Namespace CsharpSamples
	Public Class Program
		Public Shared Sub Main()
			' Create a new linked list of integers
			Dim linkedList As New LinkedList(Of Integer)()

			' Add elements to the linked list
			linkedList.AddLast(10)
			linkedList.AddLast(20)
			linkedList.AddLast(30)
			linkedList.AddLast(40)

			' Traverse and print the elements of the linked list
			Console.WriteLine("Traverse Linked List elements:")
			For Each item In linkedList
				Console.WriteLine(item)
			Next item

			' Display number of linked list elements
			Console.WriteLine($"Number of Linked List elements: {linkedList.Count}")

			' Find/Search for an element in the linked list
			Console.WriteLine(vbLf & "Find/Search Element Linked List elements: 30")
			Dim foundNode = linkedList.Find(30)

			If foundNode IsNot Nothing Then
				Console.WriteLine($"Found Value: {foundNode.Value}, " & $"Next Element: {(If(foundNode.Next IsNot Nothing, foundNode.Next.Value.ToString(), "null"))}, " & $"Previous Element: {(If(foundNode.Previous IsNot Nothing, foundNode.Previous.Value.ToString(), "null"))}")
			End If

			' Insert an element at a specified node
			Dim current As LinkedListNode(Of Integer) = linkedList.Find(20)
			If current IsNot Nothing Then
				linkedList.AddAfter(current, 25)
			End If

			Console.WriteLine($vbLf & "Number of Linked List elements: {linkedList.Count}")
			Console.WriteLine(vbLf & "Linked List elements after insertion:")
			For Each item In linkedList
				Console.WriteLine(item)
			Next item

			' Remove an existing node from the linked list
			linkedList.Remove(30)

			Console.WriteLine(vbLf & "Linked List elements after removal:")
			For Each item In linkedList
				Console.WriteLine(item)
			Next item

			Console.WriteLine($vbLf & "Number of Linked List elements: {linkedList.Count}")
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

Explication du code

  1. Créer une nouvelle liste chaînée d'entiers en utilisant new LinkedList<int>().
  2. Ajouter des objets avec des valeurs spécifiées à la liste chaînée.
  3. Parcourir et imprimer les éléments de la liste chaînée à l'aide d'une boucle foreach.
  4. Trouver/rechercher un élément dans la liste chaînée.
  5. Insérer un élément à un nœud spécifié en utilisant les méthodes Find et AddAfter.
  6. Retirer un nœud existant de la liste chaînée en utilisant la méthode Remove.

Sortie

Liste chaînée C# (Comment ça fonctionne pour les développeurs) : Figure 1 - Sortie de la liste chaînée

Présentation d'IronPDF

Découvrez-en plus sur IronPDF est une bibliothèque PDF C# puissante développée et maintenue par Iron Software. Elle fournit un ensemble complet de fonctionnalités pour créer, éditer, et extraire le contenu de documents PDF dans les projets .NET.

Points clés sur IronPDF

Conversion HTML en PDF

IronPDF vous permet de convertir du contenu HTML au format PDF. Vous pouvez facilement rendre des pages HTML, des URL et des chaînes HTML en PDF.

API riche

La bibliothèque offre une API conviviale permettant aux développeurs de générer des PDF de qualité professionnelle directement à partir de HTML. Que vous ayez besoin de créer des factures, des rapports ou d'autres documents, IronPDF simplifie le processus.

Support Multiplateforme

IronPDF est compatible avec divers environnements .NET, incluant .NET Core, .NET Standard et .NET Framework. Il fonctionne sur les plateformes Windows, Linux et macOS.

Polyvalence

IronPDF prend en charge différents types de projets, tels que les applications web (Blazor et WebForms), les applications de bureau (WPF et MAUI), et les applications de console.

Sources de contenu

Vous pouvez générer des PDFs à partir de diverses sources de contenu, y compris des fichiers HTML, des vues Razor (Blazor Server), des CSHTML (MVC et Razor), des ASPX (WebForms), et des XAML (MAUI).

Fonctionnalités additionnelles

  1. Ajouter des en-têtes et pieds de page aux PDFs.
  2. Fusionner, diviser, ajouter, copier et supprimer des pages PDF.
  3. Définir des mots de passe, des autorisations, et des signatures numériques.
  4. Optimiser les performances avec la prise en charge du multithreading et de l'asynchrone.

Compatibilité

IronPDF se conforme aux normes PDF, y compris les versions 1.2 à 1.7, PDF/UA, et PDF/A. Il prend également en charge l'encodage de caractères UTF-8, les URLs de base, et l'encodage des ressources.

Générer un document PDF en utilisant LinkedList

Maintenant, créons un document PDF en utilisant IronPDF et démontrons également l'utilisation des chaînes LinkedList.

Pour commencer, ouvrez Visual Studio et créez une application console en sélectionnant parmi les modèles de projet comme indiqué ci-dessous.

Liste chaînée C# (Comment ça fonctionne pour les développeurs) : Figure 2 - Nouveau projet

Fournissez un nom et un emplacement de projet.

Liste chaînée C# (Comment ça fonctionne pour les développeurs) : Figure 3 - Configuration du projet

Sélectionnez la version .NET requise.

Liste chaînée C# (Comment ça fonctionne pour les développeurs) : Figure 4 - Cadre cible

Installez IronPDF à partir du gestionnaire de paquets de Visual Studio comme celui ci-dessous.

Liste chaînée C# (Comment ça fonctionne pour les développeurs) : Figure 5 - Installer IronPDF

Ou il peut être installé en utilisant la ligne de commande ci-dessous.

dotnet add package IronPdf --version 2024.4.2

Ajoutez le code ci-dessous.

using System;
using System.Collections.Generic;
using IronPdf;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            var content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>";
            content += "<h2>Create a new linked list of strings</h2>";
            content += "<p>Create a new linked list of strings with new LinkedList&lt;string&gt;()</p>";

            // Create a new linked list of strings
            LinkedList<string> linkedList = new LinkedList<string>();

            // Add elements to the linked list
            content += "<p>Add Apple to linkedList</p>";
            linkedList.AddLast("Apple");

            content += "<p>Add Banana to linkedList</p>";
            linkedList.AddLast("Banana");

            content += "<p>Add Orange to linkedList</p>";
            linkedList.AddLast("Orange");

            content += "<h2>Print the elements of the linked list</h2>";
            Console.WriteLine("Linked List elements:");

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Insert an element at a specific position</h2>";
            LinkedListNode<string> node = linkedList.Find("Banana");
            if (node != null)
            {
                linkedList.AddAfter(node, "Mango");
                content += "<p>Find Banana and insert Mango After</p>";
            }

            Console.WriteLine("\nLinked List elements after insertion:");
            content += "<h2>Linked List elements after insertion:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Remove an element from the linked list</h2>";
            linkedList.Remove("Orange");
            content += "<p>Remove Orange from linked list</p>";

            Console.WriteLine("\nLinked List elements after removal:");
            content += "<h2>Linked List elements after removal:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            // Create a PDF renderer
            var renderer = new ChromePdfRenderer();

            // Create a PDF from HTML string
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Save to a file
            pdf.SaveAs("AwesomeIronOutput.pdf");
        }
    }
}
using System;
using System.Collections.Generic;
using IronPdf;

namespace CsharpSamples
{
    public class Program
    {
        public static void Main()
        {
            var content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>";
            content += "<h2>Create a new linked list of strings</h2>";
            content += "<p>Create a new linked list of strings with new LinkedList&lt;string&gt;()</p>";

            // Create a new linked list of strings
            LinkedList<string> linkedList = new LinkedList<string>();

            // Add elements to the linked list
            content += "<p>Add Apple to linkedList</p>";
            linkedList.AddLast("Apple");

            content += "<p>Add Banana to linkedList</p>";
            linkedList.AddLast("Banana");

            content += "<p>Add Orange to linkedList</p>";
            linkedList.AddLast("Orange");

            content += "<h2>Print the elements of the linked list</h2>";
            Console.WriteLine("Linked List elements:");

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Insert an element at a specific position</h2>";
            LinkedListNode<string> node = linkedList.Find("Banana");
            if (node != null)
            {
                linkedList.AddAfter(node, "Mango");
                content += "<p>Find Banana and insert Mango After</p>";
            }

            Console.WriteLine("\nLinked List elements after insertion:");
            content += "<h2>Linked List elements after insertion:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            content += "<h2>Remove an element from the linked list</h2>";
            linkedList.Remove("Orange");
            content += "<p>Remove Orange from linked list</p>";

            Console.WriteLine("\nLinked List elements after removal:");
            content += "<h2>Linked List elements after removal:</h2>";

            foreach (var item in linkedList)
            {
                content += $"<p>{item}</p>";
                Console.WriteLine(item);
            }

            // Create a PDF renderer
            var renderer = new ChromePdfRenderer();

            // Create a PDF from HTML string
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Save to a file
            pdf.SaveAs("AwesomeIronOutput.pdf");
        }
    }
}
Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports IronPdf

Namespace CsharpSamples
	Public Class Program
		Public Shared Sub Main()
			Dim content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>"
			content &= "<h2>Create a new linked list of strings</h2>"
			content &= "<p>Create a new linked list of strings with new LinkedList&lt;string&gt;()</p>"

			' Create a new linked list of strings
			Dim linkedList As New LinkedList(Of String)()

			' Add elements to the linked list
			content &= "<p>Add Apple to linkedList</p>"
			linkedList.AddLast("Apple")

			content &= "<p>Add Banana to linkedList</p>"
			linkedList.AddLast("Banana")

			content &= "<p>Add Orange to linkedList</p>"
			linkedList.AddLast("Orange")

			content &= "<h2>Print the elements of the linked list</h2>"
			Console.WriteLine("Linked List elements:")

			For Each item In linkedList
				content &= $"<p>{item}</p>"
				Console.WriteLine(item)
			Next item

			content &= "<h2>Insert an element at a specific position</h2>"
			Dim node As LinkedListNode(Of String) = linkedList.Find("Banana")
			If node IsNot Nothing Then
				linkedList.AddAfter(node, "Mango")
				content &= "<p>Find Banana and insert Mango After</p>"
			End If

			Console.WriteLine(vbLf & "Linked List elements after insertion:")
			content &= "<h2>Linked List elements after insertion:</h2>"

			For Each item In linkedList
				content &= $"<p>{item}</p>"
				Console.WriteLine(item)
			Next item

			content &= "<h2>Remove an element from the linked list</h2>"
			linkedList.Remove("Orange")
			content &= "<p>Remove Orange from linked list</p>"

			Console.WriteLine(vbLf & "Linked List elements after removal:")
			content &= "<h2>Linked List elements after removal:</h2>"

			For Each item In linkedList
				content &= $"<p>{item}</p>"
				Console.WriteLine(item)
			Next item

			' Create a PDF renderer
			Dim renderer = New ChromePdfRenderer()

			' Create a PDF from HTML string
			Dim pdf = renderer.RenderHtmlAsPdf(content)

			' Save to a file
			pdf.SaveAs("AwesomeIronOutput.pdf")
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

Explication du code

  1. Premièrement, nous commençons par créer le contenu pour le PDF, en utilisant un objet de chaîne de contenu. Le contenu est généré comme une chaîne HTML.
  2. Créez une nouvelle liste chaînée de chaînes avec new LinkedList<string>().
  3. Ajoutez des éléments à la liste chaînée et ajoutez également des informations à la chaîne de contenu PDF.
  4. Imprimez les éléments de la liste chaînée et ajoutez-les au contenu PDF.
  5. Insérez un élément à une position spécifique en utilisant la méthode AddAfter; mettez à jour le contenu et imprimez la liste résultante. 6. Retirez un élément de la liste chaînée en utilisant la méthode Remove, mettez à jour le contenu et imprimez la liste résultante.
  6. Enfin, enregistrez la chaîne de contenu HTML générée en un document PDF en utilisant les méthodes ChromePdfRenderer, RenderHtmlAsPdf, et SaveAs. Liste chaînée C# (Comment ça fonctionne pour les développeurs) : Figure 6 - IronPDF avec sortie `LinkedList`

Sortie

La sortie a un filigrane qui peut être supprimé en utilisant une licence valide depuis la page de licence IronPDF.

La page de licence du produit.

Licence IronPDF

The IronPDF library requires a license to run, and it can be obtained from the product licensing page.

Le LinkedList en C# fournit une structure de données polyvalente pour gérer des collections d'éléments, offrant des insertions et suppressions efficaces tout en permettant un redimensionnement dynamique, similaire à la fonction de hachage par défaut.

{
  "IronPdf.License.LicenseKey": "The Key Goes Here"
}

Conclusion

Les listes chaînées sont couramment utilisées dans diverses applications et algorithmes, comme l'implémentation de piles, de files d'attente, de tables de symboles et de systèmes de gestion de la mémoire. Comprendre les caractéristiques et opérations des listes chaînées est essentiel pour construire des solutions logicielles efficaces et évolutives. En résumé, bien que les listes chaînées excellent dans certains scénarios, tels que les structures de données dynamiques et les insertions/suppressions fréquentes, elles peuvent ne pas être le meilleur choix pour les applications nécessitant un accès aléatoire fréquent ou traitant des environnements limités en mémoire.

Une considération attentive des exigences et caractéristiques spécifiques des données peut guider la sélection de la structure de données la plus appropriée pour la tâche à accomplir. La bibliothèque IronPDF de Iron Software permet aux développeurs de créer et manipuler des documents PDF sans effort, permettant l'acquisition de compétences avancées pour développer des applications modernes.

The IronPDF library from Iron Software allows developers to create and manipulate PDF documents effortlessly, enabling advanced skills to develop modern applications.

Questions Fréquemment Posées

Qu'est-ce qu'une liste chaînée en C# ?

Une liste chaînée en C# est une structure de données linéaire composée de nœuds, chaque nœud contenant des données et une référence au nœud suivant. Cette structure, contrairement aux tableaux, permet une allocation de mémoire dynamique, permettant de stocker des éléments dans des emplacements de mémoire non contigus.

Comment puis-je convertir HTML en PDF en C# ?

Vous pouvez utiliser la méthode RenderHtmlAsPdf de IronPDF pour convertir des chaînes HTML en fichiers PDF. Elle vous permet également de convertir des fichiers HTML en fichiers PDF en utilisant RenderHtmlFileAsPdf.

Quels sont les types de listes chaînées en C# ?

En C#, les principaux types de listes chaînées sont les listes simplement chaînées, les listes doublement chaînées et les listes circulaires. Les listes simplement chaînées ont des nœuds avec une seule référence au nœud suivant, les listes doublement chaînées ont des références aux nœuds suivant et précédent, et les listes circulaires ont le dernier nœud pointant vers le premier nœud.

Quelles opérations de base peuvent être effectuées sur les listes chaînées ?

Les listes chaînées supportent des opérations telles que l'insertion (ajouter un nouveau nœud), la suppression (retirer un nœud existant), le parcours (itérer à travers la liste), et la recherche (trouver un nœud en fonction de ses données).

Comment implémenter une liste chaînée en C# ?

Une liste chaînée peut être implémentée en C# en utilisant la classe LinkedList du namespace System.Collections.Generic, qui fournit des méthodes pour ajouter, retirer et manipuler les nœuds de la liste.

Quelles fonctionnalités offre une bibliothèque de génération de PDF ?

Une bibliothèque de génération de PDF comme IronPDF offre la conversion HTML en PDF, l'extraction de texte, la fusion et la séparation de documents, ainsi que la définition des autorisations de document, le tout dans différents environnements .NET.

Comment les listes chaînées peuvent-elles être utilisées avec la génération de PDF ?

Les listes chaînées peuvent dynamiquement stocker et organiser du contenu, qui peut ensuite être itéré et converti en document PDF à l'aide d'une bibliothèque comme IronPDF, facilitant la manipulation et l'exportation du contenu.

Quels sont les avantages de l'utilisation des listes chaînées dans le développement logiciel ?

Les listes chaînées offrent des insertions et suppressions efficaces, un redimensionnement dynamique, et sont bénéfiques pour implémenter des structures de données dynamiques comme les piles et les files d'attente. Elles sont particulièrement utiles lorsqu'on a besoin de modifications fréquentes, bien qu'elles manquent de capacités d'accès aléatoire.

Quelle est la différence entre les listes chaînées simples et doublement chaînées ?

La différence principale est que les listes simplement chaînées ont des nœuds avec une référence simple au nœud suivant, permettant un parcours à sens unique, tandis que les listes doublement chaînées ont des nœuds avec des références à la fois au nœud suivant et précédent, permettant un parcours bidirectionnel.

Comment générer un PDF à partir de données de liste chaînée en C# ?

Vous pouvez itérer à travers la liste chaînée pour collecter des données, puis utiliser l'API d'IronPDF pour rendre ces données dans un document PDF. Cela implique de tirer parti de méthodes comme HtmlToPdf pour convertir un contenu structuré en un format PDF professionnel.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit