El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

Els generics són una característica poderosa de TypeScript que permeten crear components reutilitzables que poden treballar amb diferents tipus de dades. Això proporciona una manera de crear funcions, classes i interfícies que no estan limitades a un sol tipus de dades, augmentant així la flexibilitat i la reutilització del codi.

Conceptes Clau

Definició de Generics:
- Els generics permeten definir funcions, classes o interfícies que poden treballar amb qualsevol tipus de dades.
- S'utilitzen per evitar la repetició de codi i per garantir la seguretat de tipus.
Sintaxi de Generics:
- Els generics es defineixen utilitzant els símbols <T>, on T és un marcador de posició per a un tipus que es determinarà en el moment de la invocació.
Avantatges dels Generics:
- Reutilització del Codi: Permeten escriure codi més genèric i reutilitzable.
- Seguretat de Tipus: Proporcionen verificació de tipus en temps de compilació.
- Flexibilitat: Permeten treballar amb diferents tipus de dades sense perdre la seguretat de tipus.

Exemples Pràctics

Funcions Generiques

Una funció genèrica pot acceptar arguments de qualsevol tipus i retornar un valor del mateix tipus:

function identity<T>(arg: T): T {
    return arg;
}

// Ús de la funció genèrica
let output1 = identity<string>("Hola, món!"); // T és string
let output2 = identity<number>(42); // T és number

Classes Generiques

Les classes generiques permeten crear estructures de dades que poden treballar amb qualsevol tipus:

class Caixa<T> {
    private contingut: T;

    constructor(contingut: T) {
        this.contingut = contingut;
    }

    getContingut(): T {
        return this.contingut;
    }
}

// Ús de la classe genèrica
let caixaDeNombres = new Caixa<number>(123);
console.log(caixaDeNombres.getContingut()); // 123

let caixaDeText = new Caixa<string>("Hola");
console.log(caixaDeText.getContingut()); // Hola

Interfícies Generiques

Les interfícies generiques permeten definir contractes que poden treballar amb qualsevol tipus:

interface Parell<T, U> {
    primer: T;
    segon: U;
}

let parell: Parell<string, number> = { primer: "Hola", segon: 42 };
console.log(parell);

Exercicis Pràctics

Exercici 1: Funció Genèrica

Crea una funció genèrica reverseArray que accepti un array de qualsevol tipus i retorni un nou array amb els elements en ordre invers.

function reverseArray<T>(items: T[]): T[] {
    return items.reverse();
}

// Prova la funció
let nombres = [1, 2, 3, 4];
let text = ["a", "b", "c", "d"];

console.log(reverseArray(nombres)); // [4, 3, 2, 1]
console.log(reverseArray(text)); // ["d", "c", "b", "a"]

Exercici 2: Classe Genèrica

Crea una classe genèrica Stack que implementi una estructura de dades de pila (LIFO).

class Stack<T> {
    private elements: T[] = [];

    push(element: T): void {
        this.elements.push(element);
    }

    pop(): T | undefined {
        return this.elements.pop();
    }

    peek(): T | undefined {
        return this.elements[this.elements.length - 1];
    }

    isEmpty(): boolean {
        return this.elements.length === 0;
    }
}

// Prova la classe
let stack = new Stack<number>();
stack.push(10);
stack.push(20);
console.log(stack.pop()); // 20
console.log(stack.peek()); // 10

Conclusió

Els generics en TypeScript són una eina essencial per crear codi flexible i reutilitzable. Permeten treballar amb diferents tipus de dades sense comprometre la seguretat de tipus, cosa que és crucial en projectes grans i complexos. Practicar amb generics ajudarà a millorar la teva capacitat per escriure codi més net i eficient.

Generics en TypeScript

Conceptes Clau

Exemples Pràctics

Funcions Generiques

Classes Generiques

Interfícies Generiques

Exercicis Pràctics

Exercici 1: Funció Genèrica

Exercici 2: Classe Genèrica

Conclusió

Dramaturg amb TypeScript: De Principiant a Avançat

Mòdul 1: Introducció a Playwright i TypeScript

Mòdul 2: Començant amb Playwright

Mòdul 3: Fonaments de Playwright i TypeScript

Mòdul 4: Funcions Avançades de Playwright

Mòdul 5: Estratègies d'Automatització de Proves

Mòdul 6: Tècniques Avançades de TypeScript

Mòdul 7: Aplicacions Reals de Playwright

Mòdul 8: Conclusió del Curs i Propers Passos