ES2025 · TypeScript 7.0

Ejercicios de JavaScript / TypeScript sobre TypeScript

10 ejercicios de TypeScript en JavaScript / TypeScript. Piensa la respuesta antes de abrirla: la explicación dice por qué las demás opciones fallan.

Prueba cuatro ejercicios sin cuenta Crear cuenta gratis

1 · Elige la respuesta · nivel 1
¿Qué valores acepta id?
```
let id: string | number;
```
- AUn string o un number
- BSolo un string que contenga un número
- CUn objeto con un string y un number
- DCualquier valor
Ver la respuesta
Respuesta: A. Un string o un number
| crea un tipo unión: id puede ser de cualquiera de los dos tipos. Antes de usar métodos propios de uno, hay que comprobar cuál es con typeof.
2 · Elige la respuesta · nivel 1
¿Qué imprime este código?
```
function greet(name: string, title?: string) {  return title ? `${title} ${name}` : name;} console.log(greet("Ana"));
```
- AAna
- Bundefined Ana
- CAna undefined
- DNada: no compila sin title
Ver la respuesta
Respuesta: A. Ana
El ? marca title como opcional: se puede llamar a la función sin él. Si no se pasa, vale undefined, el condicional lo trata como falso y se devuelve solo el nombre.
3 · Completa el hueco · nivel 1
Completa el tipo para que TypeScript no deje modificar el array con push.
```
const nums: ___ number[] = [1, 2, 3];console.log(nums.length);
```
- readonly
- const
- static
- final
Ver la respuesta
Respuesta: readonly
```
const nums: readonly number[] = [1, 2, 3];console.log(nums.length);
```
readonly number[] es un array de solo lectura: TypeScript marca error en push, pop o en asignar nums[0]. const solo impide reasignar la variable, no cambiar el contenido; static y final no existen en los tipos.
4 · Ordena las líneas · nivel 1
Ordena una interfaz User con name obligatorio y age opcional (en ese orden) y un objeto válido.
- age: number;
- age?: number;
- name: string;
- }
- const ana: User = { name: "Ana" };
- interface User {
Ver la respuesta
El orden correcto:
```
interface User {  name: string;  age?: number;}const ana: User = { name: "Ana" };
```
Sobran: age: number;
El ? marca la propiedad como opcional, por eso el objeto es válido sin age. Con age: number, TypeScript lo rechazaría.
5 · Elige la respuesta · nivel 2
¿Qué imprime este código?
```
enum Color { Red, Green, Blue }console.log(Color.Green, Color[2]);
```
- A1 Blue
- BGreen Blue
- C1 2
- DGreen 2
Ver la respuesta
Respuesta: A. 1 Blue
Un enum numérico empieza en 0 y genera un mapeo en los dos sentidos: Color.Green es 1 y Color[2] es "Blue". Por eso muchos proyectos prefieren uniones de strings, que no generan código.
6 · Elige la respuesta · nivel 2
¿Qué imprime este código?
```
function show(value: unknown) {  if (typeof value === "string") {    return value.toUpperCase();  }  return "no es texto";} console.log(show(42));
```
- Ano es texto
- B42
- Cundefined
- DError en ejecución: 42 no tiene toUpperCase
Ver la respuesta
Respuesta: A. no es texto
unknown obliga a comprobar el tipo antes de usar el valor. Dentro del if, TypeScript sabe que value es un string; con 42 no se entra y se devuelve el texto de reserva.
7 · Elige la respuesta · nivel 2
¿Qué imprime este código?
```
const n = "5" as unknown as number;console.log(typeof n);
```
- Astring
- Bnumber
- Cundefined
- DError
Ver la respuesta
Respuesta: A. string
Los tipos de TypeScript desaparecen al compilar: as solo le dice al compilador qué creer, no convierte nada. En ejecución n sigue siendo el string "5". Para convertir hay que usar Number("5").
8 · Completa el hueco · nivel 2
Completa para comprobar que dark cumple Theme sin perder los tipos literales de sus valores.
```
type Theme = Record<"bg" | "fg", string>; const dark = {  bg: "#0B1210",  fg: "#DFF7EC",} ___ Theme;
```
- satisfies
- as
- extends
- implements
- is
Ver la respuesta
Respuesta: satisfies
```
type Theme = Record<"bg" | "fg", string>; const dark = {  bg: "#0B1210",  fg: "#DFF7EC",} satisfies Theme;
```
satisfies valida el valor contra el tipo pero conserva el tipo inferido. as, en cambio, lo fuerza y puede ocultar errores.
9 · Completa el hueco · nivel 2
Completa para distinguir entre un string y un array de strings.
```
function len(value: string | string[]) {  if (___ value === "string") return value.length;  return value.___;}console.log(len("hola"), len(["a", "b"]));
```
- typeof
- length
- instanceof
- size
- keyof
- count
Ver la respuesta
Respuesta: typeof · length
```
function len(value: string | string[]) {  if (typeof value === "string") return value.length;  return value.length;}console.log(len("hola"), len(["a", "b"]));
```
typeof devuelve el tipo en tiempo de ejecución como texto y TypeScript lo usa para estrechar el tipo dentro del if. keyof es un operador de tipos y no existe al ejecutar.
10 · Ordena las líneas · nivel 2
Ordena la función genérica first y, después, un ejemplo de uso.
- return items[0];
- }
- console.log(n);
- const n = first([7, 8]);
- function first(items: T[]): T {
- function first<T>(items: T[]): T | undefined {
Ver la respuesta
El orden correcto:
```
function first<T>(items: T[]): T | undefined {  return items[0];}const n = first([7, 8]);console.log(n);
```
Sobran: function first(items: T[]): T {
<T> declara un parámetro de tipo: al llamar con [7, 8], TypeScript deduce que T es number. Sin declarar <T> el tipo no existe. T | undefined avisa de que el array puede estar vacío.

Más temas de JavaScript / TypeScript

Ver toda la ruta de JavaScript / TypeScript