897 lines
20 KiB
Go
897 lines
20 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
|
|
"github.com/landaiqing/freezelib"
|
|
)
|
|
|
|
func main() {
|
|
fmt.Println("💻 Programming Languages Examples")
|
|
fmt.Println("=================================")
|
|
|
|
// Create output directory
|
|
os.MkdirAll("output", 0755)
|
|
|
|
// Run language examples
|
|
popularLanguagesExample()
|
|
languageComparisonExample()
|
|
multiLanguageProjectExample()
|
|
languageSpecificFeaturesExample()
|
|
|
|
fmt.Println("\n✅ Language examples completed!")
|
|
fmt.Println("📁 Check the 'output' directory for generated files.")
|
|
}
|
|
|
|
// Popular programming languages showcase
|
|
func popularLanguagesExample() {
|
|
fmt.Println("\n🌟 Popular Languages Showcase")
|
|
fmt.Println("-----------------------------")
|
|
|
|
// Language examples with sample code
|
|
languages := []struct {
|
|
name string
|
|
code string
|
|
lang string
|
|
}{
|
|
{
|
|
"go",
|
|
`package main
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
)
|
|
|
|
func main() {
|
|
fmt.Println("Hello from Go!")
|
|
|
|
// Goroutine example
|
|
go func() {
|
|
fmt.Println("This runs concurrently")
|
|
}()
|
|
|
|
time.Sleep(time.Millisecond * 100)
|
|
}`,
|
|
"go",
|
|
},
|
|
{
|
|
"python",
|
|
`import asyncio
|
|
from dataclasses import dataclass
|
|
|
|
@dataclass
|
|
class User:
|
|
name: str
|
|
age: int
|
|
email: str
|
|
|
|
async def fetch_user(user_id: int) -> User:
|
|
# Simulate API call
|
|
await asyncio.sleep(1)
|
|
return User(name="John Doe", age=30, email="john@example.com")
|
|
|
|
async def main():
|
|
user = await fetch_user(123)
|
|
print(f"User: {user.name}, {user.age}, {user.email}")
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main())`,
|
|
"python",
|
|
},
|
|
{
|
|
"javascript",
|
|
`// Modern JavaScript example
|
|
const fetchData = async () => {
|
|
try {
|
|
const response = await fetch('https://api.example.com/data');
|
|
const data = await response.json();
|
|
|
|
// Destructuring and spread operator
|
|
const { items, meta } = data;
|
|
const allItems = [...items, { id: 'new', value: 42 }];
|
|
|
|
// Array methods
|
|
const filtered = allItems.filter(item => item.value > 10);
|
|
|
|
return filtered;
|
|
} catch (error) {
|
|
console.error('Error fetching data:', error);
|
|
return [];
|
|
}
|
|
};
|
|
|
|
// Call the function
|
|
fetchData().then(result => console.log(result));`,
|
|
"javascript",
|
|
},
|
|
{
|
|
"rust",
|
|
`use std::collections::HashMap;
|
|
|
|
#[derive(Debug)]
|
|
struct User {
|
|
name: String,
|
|
age: u32,
|
|
active: bool,
|
|
}
|
|
|
|
fn main() {
|
|
// Create a new User
|
|
let user = User {
|
|
name: String::from("Alice"),
|
|
age: 28,
|
|
active: true,
|
|
};
|
|
|
|
// Using a HashMap
|
|
let mut scores = HashMap::new();
|
|
scores.insert(String::from("Blue"), 10);
|
|
scores.insert(String::from("Yellow"), 50);
|
|
|
|
// Pattern matching
|
|
match user.age {
|
|
0..=17 => println!("{} is underage", user.name),
|
|
18..=64 => println!("{} is an adult", user.name),
|
|
_ => println!("{} is a senior", user.name),
|
|
}
|
|
}`,
|
|
"rust",
|
|
},
|
|
{
|
|
"java",
|
|
`import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
|
|
public class StreamExample {
|
|
public static void main(String[] args) {
|
|
// Create a list of names
|
|
List<String> names = List.of("Alice", "Bob", "Charlie", "David");
|
|
|
|
// Use streams to filter and transform
|
|
List<String> filteredNames = names.stream()
|
|
.filter(name -> name.length() > 4)
|
|
.map(String::toUpperCase)
|
|
.sorted()
|
|
.collect(Collectors.toList());
|
|
|
|
// Print the results
|
|
System.out.println("Original names: " + names);
|
|
System.out.println("Filtered names: " + filteredNames);
|
|
}
|
|
}`,
|
|
"java",
|
|
},
|
|
{
|
|
"csharp",
|
|
`using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace LinqExample
|
|
{
|
|
class Program
|
|
{
|
|
static void Main(string[] args)
|
|
{
|
|
// Create a list of products
|
|
var products = new List<Product>
|
|
{
|
|
new Product { Id = 1, Name = "Laptop", Price = 1200.00m, Category = "Electronics" },
|
|
new Product { Id = 2, Name = "Desk Chair", Price = 250.50m, Category = "Furniture" },
|
|
new Product { Id = 3, Name = "Coffee Maker", Price = 89.99m, Category = "Kitchen" },
|
|
new Product { Id = 4, Name = "Tablet", Price = 400.00m, Category = "Electronics" }
|
|
};
|
|
|
|
// Use LINQ to query products
|
|
var expensiveElectronics = products
|
|
.Where(p => p.Category == "Electronics" && p.Price > 500)
|
|
.OrderBy(p => p.Price)
|
|
.Select(p => new { p.Name, p.Price });
|
|
|
|
Console.WriteLine("Expensive Electronics:");
|
|
foreach (var item in expensiveElectronics)
|
|
{
|
|
Console.WriteLine($"{item.Name}: ${item.Price}");
|
|
}
|
|
}
|
|
}
|
|
|
|
class Product
|
|
{
|
|
public int Id { get; set; }
|
|
public string Name { get; set; }
|
|
public decimal Price { get; set; }
|
|
public string Category { get; set; }
|
|
}
|
|
}`,
|
|
"csharp",
|
|
},
|
|
}
|
|
|
|
// Create a consistent style for all languages
|
|
freeze := freezelib.New().
|
|
WithTheme("github-dark").
|
|
WithFont("JetBrains Mono", 14).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(15, 0, 8).
|
|
WithPadding(20)
|
|
|
|
for _, lang := range languages {
|
|
fmt.Printf("📝 Generating %s example...\n", lang.name)
|
|
|
|
svgData, err := freeze.GenerateFromCode(lang.code, lang.lang)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error with %s: %v\n", lang.name, err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/language_%s.svg", lang.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving %s: %v\n", filename, err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s\n", filename)
|
|
}
|
|
}
|
|
|
|
// Language comparison with the same algorithm
|
|
func languageComparisonExample() {
|
|
fmt.Println("\n🔄 Same Algorithm in Different Languages")
|
|
fmt.Println("---------------------------------------")
|
|
|
|
// Fibonacci implementation in different languages
|
|
fibImplementations := []struct {
|
|
name string
|
|
code string
|
|
lang string
|
|
}{
|
|
{
|
|
"go",
|
|
`package main
|
|
|
|
import "fmt"
|
|
|
|
// Recursive Fibonacci implementation
|
|
func fibonacci(n int) int {
|
|
if n <= 1 {
|
|
return n
|
|
}
|
|
return fibonacci(n-1) + fibonacci(n-2)
|
|
}
|
|
|
|
// Iterative Fibonacci implementation
|
|
func fibonacciIterative(n int) int {
|
|
if n <= 1 {
|
|
return n
|
|
}
|
|
|
|
a, b := 0, 1
|
|
for i := 2; i <= n; i++ {
|
|
a, b = b, a+b
|
|
}
|
|
return b
|
|
}
|
|
|
|
func main() {
|
|
n := 10
|
|
fmt.Printf("Fibonacci(%d) = %d (recursive)\n", n, fibonacci(n))
|
|
fmt.Printf("Fibonacci(%d) = %d (iterative)\n", n, fibonacciIterative(n))
|
|
}`,
|
|
"go",
|
|
},
|
|
{
|
|
"python",
|
|
`def fibonacci_recursive(n):
|
|
"""Calculate Fibonacci number recursively."""
|
|
if n <= 1:
|
|
return n
|
|
return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)
|
|
|
|
def fibonacci_iterative(n):
|
|
"""Calculate Fibonacci number iteratively."""
|
|
if n <= 1:
|
|
return n
|
|
|
|
a, b = 0, 1
|
|
for i in range(2, n+1):
|
|
a, b = b, a + b
|
|
return b
|
|
|
|
def fibonacci_dynamic(n):
|
|
"""Calculate Fibonacci number using dynamic programming."""
|
|
memo = {0: 0, 1: 1}
|
|
|
|
def fib(n):
|
|
if n not in memo:
|
|
memo[n] = fib(n-1) + fib(n-2)
|
|
return memo[n]
|
|
|
|
return fib(n)
|
|
|
|
# Test the functions
|
|
n = 10
|
|
print(f"Fibonacci({n}) = {fibonacci_recursive(n)} (recursive)")
|
|
print(f"Fibonacci({n}) = {fibonacci_iterative(n)} (iterative)")
|
|
print(f"Fibonacci({n}) = {fibonacci_dynamic(n)} (dynamic)")`,
|
|
"python",
|
|
},
|
|
{
|
|
"javascript",
|
|
`// Recursive Fibonacci implementation
|
|
function fibonacciRecursive(n) {
|
|
if (n <= 1) return n;
|
|
return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
|
|
}
|
|
|
|
// Iterative Fibonacci implementation
|
|
function fibonacciIterative(n) {
|
|
if (n <= 1) return n;
|
|
|
|
let a = 0, b = 1;
|
|
for (let i = 2; i <= n; i++) {
|
|
const temp = a + b;
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
// Fibonacci with memoization
|
|
function fibonacciMemoized(n, memo = {}) {
|
|
if (n in memo) return memo[n];
|
|
if (n <= 1) return n;
|
|
|
|
memo[n] = fibonacciMemoized(n - 1, memo) + fibonacciMemoized(n - 2, memo);
|
|
return memo[n];
|
|
}
|
|
|
|
// Test the functions
|
|
const n = 10;
|
|
console.log(Fibonacci(${n}) = ${fibonacciRecursive(n)} (recursive));
|
|
console.log(Fibonacci(${n}) = ${fibonacciIterative(n)} (iterative));
|
|
console.log(Fibonacci(${n}) = ${fibonacciMemoized(n)} (memoized));`,
|
|
"javascript",
|
|
},
|
|
{
|
|
"rust",
|
|
`fn fibonacci_recursive(n: u32) -> u32 {
|
|
match n {
|
|
0 => 0,
|
|
1 => 1,
|
|
_ => fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2),
|
|
}
|
|
}
|
|
|
|
fn fibonacci_iterative(n: u32) -> u32 {
|
|
match n {
|
|
0 => 0,
|
|
1 => 1,
|
|
_ => {
|
|
let mut a = 0;
|
|
let mut b = 1;
|
|
|
|
for _ in 2..=n {
|
|
let temp = a + b;
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
|
|
b
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let n = 10;
|
|
println!("Fibonacci({}) = {} (recursive)", n, fibonacci_recursive(n));
|
|
println!("Fibonacci({}) = {} (iterative)", n, fibonacci_iterative(n));
|
|
}`,
|
|
"rust",
|
|
},
|
|
}
|
|
|
|
// Create a consistent style for comparison
|
|
freeze := freezelib.New().
|
|
WithTheme("dracula").
|
|
WithFont("Fira Code", 14).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithPadding(20)
|
|
|
|
for _, impl := range fibImplementations {
|
|
fmt.Printf("🧮 Generating Fibonacci in %s...\n", impl.name)
|
|
|
|
svgData, err := freeze.GenerateFromCode(impl.code, impl.lang)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error with %s: %v\n", impl.name, err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/fibonacci_%s.svg", impl.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving %s: %v\n", filename, err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s\n", filename)
|
|
}
|
|
}
|
|
|
|
// Multi-language project example
|
|
func multiLanguageProjectExample() {
|
|
fmt.Println("\n🌐 Multi-language Project")
|
|
fmt.Println("-------------------------")
|
|
|
|
// Different files in a web project
|
|
projectFiles := []struct {
|
|
name string
|
|
code string
|
|
lang string
|
|
filename string
|
|
}{
|
|
{
|
|
"HTML",
|
|
`<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<title>Task Manager</title>
|
|
<link rel="stylesheet" href="styles.css">
|
|
</head>
|
|
<body>
|
|
<div class="container">
|
|
<h1>Task Manager</h1>
|
|
|
|
<div class="task-form">
|
|
<input type="text" id="taskInput" placeholder="Add a new task...">
|
|
<button id="addTask">Add</button>
|
|
</div>
|
|
|
|
<ul id="taskList" class="task-list"></ul>
|
|
|
|
<div class="stats">
|
|
<p>Total tasks: <span id="totalTasks">0</span></p>
|
|
<p>Completed: <span id="completedTasks">0</span></p>
|
|
</div>
|
|
</div>
|
|
|
|
<script src="app.js"></script>
|
|
</body>
|
|
</html>`,
|
|
"html",
|
|
"index.html",
|
|
},
|
|
{
|
|
"CSS",
|
|
`/* Task Manager Styles */
|
|
* {
|
|
box-sizing: border-box;
|
|
margin: 0;
|
|
padding: 0;
|
|
}
|
|
|
|
body {
|
|
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
|
|
line-height: 1.6;
|
|
background-color: #f5f5f5;
|
|
color: #333;
|
|
}
|
|
|
|
.container {
|
|
max-width: 800px;
|
|
margin: 2rem auto;
|
|
padding: 2rem;
|
|
background-color: white;
|
|
border-radius: 8px;
|
|
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
|
|
}
|
|
|
|
h1 {
|
|
text-align: center;
|
|
margin-bottom: 2rem;
|
|
color: #2c3e50;
|
|
}
|
|
|
|
.task-form {
|
|
display: flex;
|
|
margin-bottom: 1.5rem;
|
|
}
|
|
|
|
#taskInput {
|
|
flex: 1;
|
|
padding: 0.75rem;
|
|
border: 1px solid #ddd;
|
|
border-radius: 4px 0 0 4px;
|
|
font-size: 1rem;
|
|
}
|
|
|
|
#addTask {
|
|
padding: 0.75rem 1.5rem;
|
|
background-color: #3498db;
|
|
color: white;
|
|
border: none;
|
|
border-radius: 0 4px 4px 0;
|
|
cursor: pointer;
|
|
font-size: 1rem;
|
|
}
|
|
|
|
.task-list {
|
|
list-style: none;
|
|
margin-bottom: 1.5rem;
|
|
}
|
|
|
|
.task-list li {
|
|
padding: 1rem;
|
|
border-bottom: 1px solid #eee;
|
|
display: flex;
|
|
justify-content: space-between;
|
|
align-items: center;
|
|
}
|
|
|
|
.task-list li.completed {
|
|
text-decoration: line-through;
|
|
color: #7f8c8d;
|
|
}
|
|
|
|
.stats {
|
|
display: flex;
|
|
justify-content: space-between;
|
|
color: #7f8c8d;
|
|
font-size: 0.9rem;
|
|
}`,
|
|
"css",
|
|
"styles.css",
|
|
},
|
|
{
|
|
"JavaScript",
|
|
`// Task Manager App
|
|
document.addEventListener('DOMContentLoaded', () => {
|
|
// DOM Elements
|
|
const taskInput = document.getElementById('taskInput');
|
|
const addTaskBtn = document.getElementById('addTask');
|
|
const taskList = document.getElementById('taskList');
|
|
const totalTasksEl = document.getElementById('totalTasks');
|
|
const completedTasksEl = document.getElementById('completedTasks');
|
|
|
|
// Task array
|
|
let tasks = JSON.parse(localStorage.getItem('tasks')) || [];
|
|
|
|
// Initial render
|
|
renderTasks();
|
|
updateStats();
|
|
|
|
// Event Listeners
|
|
addTaskBtn.addEventListener('click', addTask);
|
|
taskInput.addEventListener('keypress', e => {
|
|
if (e.key === 'Enter') addTask();
|
|
});
|
|
|
|
// Add a new task
|
|
function addTask() {
|
|
const taskText = taskInput.value.trim();
|
|
if (taskText === '') return;
|
|
|
|
tasks.push({
|
|
id: Date.now(),
|
|
text: taskText,
|
|
completed: false
|
|
});
|
|
|
|
saveToLocalStorage();
|
|
renderTasks();
|
|
updateStats();
|
|
|
|
taskInput.value = '';
|
|
taskInput.focus();
|
|
}
|
|
|
|
// Toggle task completion
|
|
function toggleTask(id) {
|
|
tasks = tasks.map(task =>
|
|
task.id === id ? { ...task, completed: !task.completed } : task
|
|
);
|
|
|
|
saveToLocalStorage();
|
|
renderTasks();
|
|
updateStats();
|
|
}
|
|
|
|
// Delete a task
|
|
function deleteTask(id) {
|
|
tasks = tasks.filter(task => task.id !== id);
|
|
|
|
saveToLocalStorage();
|
|
renderTasks();
|
|
updateStats();
|
|
}
|
|
|
|
// Render tasks to DOM
|
|
function renderTasks() {
|
|
taskList.innerHTML = '';
|
|
|
|
tasks.forEach(task => {
|
|
const li = document.createElement('li');
|
|
li.className = task.completed ? 'completed' : '';
|
|
|
|
li.innerHTML =
|
|
<span onclick="toggleTask(${task.id})">${task.text}</span>
|
|
<button onclick="deleteTask(${task.id})">Delete</button>
|
|
;
|
|
|
|
taskList.appendChild(li);
|
|
});
|
|
}
|
|
|
|
// Update statistics
|
|
function updateStats() {
|
|
totalTasksEl.textContent = tasks.length;
|
|
completedTasksEl.textContent = tasks.filter(task => task.completed).length;
|
|
}
|
|
|
|
// Save to localStorage
|
|
function saveToLocalStorage() {
|
|
localStorage.setItem('tasks', JSON.stringify(tasks));
|
|
}
|
|
|
|
// Expose functions to global scope for inline event handlers
|
|
window.toggleTask = toggleTask;
|
|
window.deleteTask = deleteTask;
|
|
});`,
|
|
"javascript",
|
|
"app.js",
|
|
},
|
|
}
|
|
|
|
// Create a consistent style for the project files
|
|
freeze := freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("Cascadia Code", 13).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(10, 0, 5).
|
|
WithPadding(20)
|
|
|
|
for _, file := range projectFiles {
|
|
fmt.Printf("📄 Generating %s file (%s)...\n", file.name, file.filename)
|
|
|
|
svgData, err := freeze.GenerateFromCode(file.code, file.lang)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error with %s: %v\n", file.name, err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/project_%s.svg", file.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving %s: %v\n", filename, err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s\n", filename)
|
|
}
|
|
}
|
|
|
|
// Language-specific features example
|
|
func languageSpecificFeaturesExample() {
|
|
fmt.Println("\n✨ Language-Specific Features")
|
|
fmt.Println("----------------------------")
|
|
|
|
// Language-specific code features
|
|
features := []struct {
|
|
name string
|
|
code string
|
|
lang string
|
|
description string
|
|
}{
|
|
{
|
|
"go_concurrency",
|
|
`package main
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
|
|
defer wg.Done()
|
|
|
|
for j := range jobs {
|
|
fmt.Printf("Worker %d started job %d\n", id, j)
|
|
time.Sleep(time.Second) // Simulate work
|
|
fmt.Printf("Worker %d finished job %d\n", id, j)
|
|
results <- j * 2
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
jobs := make(chan int, 5)
|
|
results := make(chan int, 5)
|
|
|
|
// Start workers
|
|
var wg sync.WaitGroup
|
|
for w := 1; w <= 3; w++ {
|
|
wg.Add(1)
|
|
go worker(w, jobs, results, &wg)
|
|
}
|
|
|
|
// Send jobs
|
|
for j := 1; j <= 5; j++ {
|
|
jobs <- j
|
|
}
|
|
close(jobs)
|
|
|
|
// Wait for workers to finish
|
|
wg.Wait()
|
|
close(results)
|
|
|
|
// Collect results
|
|
for r := range results {
|
|
fmt.Println("Result:", r)
|
|
}
|
|
}`,
|
|
"go",
|
|
"Go Concurrency with Goroutines and Channels",
|
|
},
|
|
{
|
|
"python_decorators",
|
|
`import time
|
|
import functools
|
|
from typing import Callable, TypeVar, Any
|
|
|
|
T = TypeVar('T')
|
|
|
|
def timer(func: Callable[..., T]) -> Callable[..., T]:
|
|
"""Decorator that prints the execution time of a function."""
|
|
@functools.wraps(func)
|
|
def wrapper(*args: Any, **kwargs: Any) -> T:
|
|
start_time = time.time()
|
|
result = func(*args, **kwargs)
|
|
end_time = time.time()
|
|
print(f"{func.__name__} executed in {end_time - start_time:.4f} seconds")
|
|
return result
|
|
return wrapper
|
|
|
|
def memoize(func: Callable[..., T]) -> Callable[..., T]:
|
|
"""Decorator that caches function results."""
|
|
cache = {}
|
|
|
|
@functools.wraps(func)
|
|
def wrapper(*args: Any, **kwargs: Any) -> T:
|
|
key = str(args) + str(kwargs)
|
|
if key not in cache:
|
|
cache[key] = func(*args, **kwargs)
|
|
return cache[key]
|
|
return wrapper
|
|
|
|
@timer
|
|
@memoize
|
|
def fibonacci(n: int) -> int:
|
|
"""Calculate the nth Fibonacci number."""
|
|
if n <= 1:
|
|
return n
|
|
return fibonacci(n-1) + fibonacci(n-2)
|
|
|
|
# Test the decorated function
|
|
print(fibonacci(30)) # First call will be timed
|
|
print(fibonacci(30)) # Second call will use cached result`,
|
|
"python",
|
|
"Python Decorators and Type Annotations",
|
|
},
|
|
{
|
|
"typescript_generics",
|
|
`// TypeScript Generics and Interfaces
|
|
interface Repository<T> {
|
|
getById(id: string): Promise<T>;
|
|
getAll(): Promise<T[]>;
|
|
create(item: T): Promise<T>;
|
|
update(id: string, item: T): Promise<T>;
|
|
delete(id: string): Promise<boolean>;
|
|
}
|
|
|
|
interface User {
|
|
id?: string;
|
|
name: string;
|
|
email: string;
|
|
role: 'admin' | 'user' | 'guest';
|
|
createdAt?: Date;
|
|
}
|
|
|
|
class UserRepository implements Repository<User> {
|
|
private users: Map<string, User> = new Map();
|
|
|
|
async getById(id: string): Promise<User> {
|
|
const user = this.users.get(id);
|
|
if (!user) {
|
|
throw new Error(User with id ${id} not found);
|
|
}
|
|
return user;
|
|
}
|
|
|
|
async getAll(): Promise<User[]> {
|
|
return Array.from(this.users.values());
|
|
}
|
|
|
|
async create(user: User): Promise<User> {
|
|
const id = Math.random().toString(36).substring(2, 9);
|
|
const newUser = {
|
|
...user,
|
|
id,
|
|
createdAt: new Date()
|
|
};
|
|
this.users.set(id, newUser);
|
|
return newUser;
|
|
}
|
|
|
|
async update(id: string, user: User): Promise<User> {
|
|
if (!this.users.has(id)) {
|
|
throw new Error('User with id ${id} not found');
|
|
}
|
|
const updatedUser = { ...user, id };
|
|
this.users.set(id, updatedUser);
|
|
return updatedUser;
|
|
}
|
|
|
|
async delete(id: string): Promise<boolean> {
|
|
return this.users.delete(id);
|
|
}
|
|
}
|
|
|
|
// Usage example
|
|
async function main() {
|
|
const userRepo = new UserRepository();
|
|
|
|
const newUser = await userRepo.create({
|
|
name: 'John Doe',
|
|
email: 'john@example.com',
|
|
role: 'admin'
|
|
});
|
|
|
|
console.log('Created user:', newUser);
|
|
|
|
const allUsers = await userRepo.getAll();
|
|
console.log('All users:', allUsers);
|
|
}
|
|
|
|
main().catch(console.error);`,
|
|
"typescript",
|
|
"TypeScript Generics, Interfaces and Type Safety",
|
|
},
|
|
}
|
|
|
|
// Create a consistent style for the feature examples
|
|
freeze := freezelib.New().
|
|
WithTheme("one-dark").
|
|
WithFont("JetBrains Mono", 13).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(15, 0, 8).
|
|
WithPadding(20)
|
|
|
|
for _, feature := range features {
|
|
fmt.Printf("🔍 Generating %s example...\n", feature.name)
|
|
|
|
svgData, err := freeze.GenerateFromCode(feature.code, feature.lang)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error with %s: %v\n", feature.name, err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/feature_%s.svg", feature.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving %s: %v\n", filename, err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s - %s\n", filename, feature.description)
|
|
}
|
|
}
|