Modulo-1.md

@@ -275,8 +275,114 @@ const recursoEntidad = new RecursoEntidad(datos.id, datos.unidad, datos.tipoRecu
 recursoEntidad.mostrar();
 ```
 
+## 10.1 Propiedades opcionales (`?`) y operador de aserción no nula (`!`)
+
+En sistemas reales (como un sistema de gestión sanitaria), **no todas las propiedades están siempre disponibles**. TypeScript permite modelar esta realidad de forma segura.
+
+### Propiedades opcionales (`?`)
+
+El operador `?` indica que una propiedad **puede existir o no**. Internamente, TypeScript la trata como `tipo | undefined`.
+
+```ts
+interface RecursoDetalle {
+  id: string;
+  unidad: string;
+  tipoRecurso: TipoRecurso;
+  observaciones?: string; // propiedad opcional
+}
+```
+
+Uso práctico:
+
+```ts
+const recursoConObs: RecursoDetalle = {
+  id: 'AJS829DJ2',
+  unidad: 'JMAPER',
+  tipoRecurso: 'MATERIAL',
+  observaciones: 'Revisión pendiente',
+};
+
+const recursoSinObs: RecursoDetalle = {
+  id: 'KSI928DJ2',
+  unidad: 'ACING',
+  tipoRecurso: 'HUMANO',
+};
+```
+
+Al acceder a una propiedad opcional, **TypeScript obliga a comprobar su existencia**:
+
+```ts
+if (recursoConObs.observaciones) {
+  console.log(recursoConObs.observaciones.toUpperCase());
+}
+```
+
+Esto evita errores típicos de JavaScript en tiempo de ejecución.
+
 ---
 
+### Operador de aserción no nula (`!`)
+
+El operador `!` se utiliza cuando **el desarrollador sabe que una propiedad existe**, aunque TypeScript no pueda deducirlo.
+
+> Es una forma de decirle al compilador:
+> **“Confía en mí, esta propiedad no es `null` ni `undefined` aquí.”**
+
+Ejemplo:
+
+```ts
+class RecursoAsignado {
+  public responsable?: string;
+
+  asignar(responsable: string): void {
+    this.responsable = responsable;
+  }
+
+  mostrarResponsable(): void {
+    // TypeScript advierte que responsable podría ser undefined
+    console.log(this.responsable!.toUpperCase());
+  }
+}
+```
+
+Uso:
+
+```ts
+const recurso = new RecursoAsignado();
+recurso.asignar('Dra. Martínez');
+recurso.mostrarResponsable();
+```
+
+Aquí:
+
+* `responsable` es opcional (`?`)
+* El operador `!` indica que **en este punto concreto** sí está definido
+
+---
+
+### Buenas prácticas importantes
+
+* `?` **modela incertidumbre real del dominio**
+* `!` **debe usarse con criterio**, solo cuando:
+
+  * La lógica del programa garantiza la existencia
+  * Ya se ha validado previamente
+* Un abuso de `!` puede ocultar errores reales
+
+Ejemplo correcto:
+
+```ts
+if (recurso.responsable) {
+  console.log(recurso.responsable.toUpperCase());
+}
+```
+
+Ejemplo a evitar sin validación previa:
+
+```ts
+console.log(recurso.responsable!.toUpperCase());
+```
+
 ## 11. Otros objetos
 
 ### Date