Contenido del curso
Fundamentos de POO
POO Avanzada
Asincronismo y consumo de APIs
Genéricos
Próximos pasos
Acceso público
Migdualy Alejandra Gonzalez Martinez
student
Carlos Rodríguez
studentContenido del curso
Acceso público
Migdualy Alejandra Gonzalez Martinez
studentCarlos Rodríguez
student
Axel Enrique Galeed Gutierrez
student
Paolo Joaquin Pinto Perez
student
Brahyan Antonio Martinez Madera
student
Arnold Stuwar Pedraza Marin
student
Diego Raciel Ortega Hernandez
student
David Rangel
student
Jesús Patricio Pereira Matus
studentJesús Patricio Pereira Matus
student
Dario Mendoza
student
Valentina Hernández
studentValentina Hernández
studentValentina Hernández
studentValentina Hernández
student
Alfonso Neil Jiménez Casallas
student
Carlos Mario
student
Ronaldo Delgado
studentPaolo Joaquin Pinto Perez
student
Andrés Felipe Eslava Zuluaga
studentSi no le defines el acceso a ninguna variable por default sera pública.
Método o propiedad
¿Qué quiere decir acceso público?
Esto quiere decir que podemos acceder a las propiedades y métodos del objeto desde el exterior.
Public
Por defecto, todas las propiedades y métodos son públicos pero si queremos aclarar en nuestro código el alcance de los mismos podemos utilizar la palabra reservada public.
class nameClass { public parameter1: dataType; constructor (parameters) { statements } public method (parameters): dataType { statements } }
Desventajas del alcance público
La desventaja que tenemos al tener una propiedad o método con alcance público es que estás pueden ser modificables desde fuera de la clase.
Ejemplo
type PartOfTheCalendar = 'day' | 'month'| 'year'; export class MyDate { year: number; month: number; day: number; constructor (year: number, month: number, day: number) { this.year = year; this.month = month; this.day = day; } add (amount: number, type: PartOfTheCalendar) { if (type === 'day') this.day += amount; if (type === 'month') this.month += amount; if (type === 'year') this. year += amount; } } const myDate = new MyDate(2000, 11, 10); myDate.day = 12; MyDate.prototype.add = function () { console.log('Change'); }; console.log(myDate.day); myDate.add(13, 'day');
Que ironia que ahora se parece más a java. jeje El encapsulamiento es lo mejor :D
Js fue mi amor a primera vista, ts fue mi amor maduro XD
y asi inicia el encapsulamiento.
Nunca supe que era el acceso publico o privado :0 ahora lo se :'3
Amé la clase. Apenas estoy empezando a aprender de backend y esto me hacer pensar que los gets podrían ser o read only. Y por ejemplo si haces un id de referencia entre bases de datos, este podría ser private.
la verdad que bueno venir de aprender java a aprender TS para ver angular porque te facilita entender la POO ya que java esta hecho sobre este paradigma de la programacion, en resumen les digo la POO esta hecho de 4 pilares, abstraccion, encapsulamiento, polimorfismo y herencia, la abstraccion viene de traer los objetos reales o conceptuales a la programacion o al mundo logico, el encapsulamiento trata de encapsular los datos con los accesos que se hablan en esta clase y obtenerlos via get y set que es obtener o cambiar que se hablan despues, polimorfismo trata de que algo lo puede hacer diferente ejemplo una clase animal puede hacer un sonido pero cada tipo de animal lo hara diferente, herencia es que las clases pueden heredar atributos y propiedades de otras clases ejemplo una persona puede ser trabajador
agrego al ultimo ejemplo una persona puede ser trabajador pero seguira teniendo propiedades y metodos de un trabajador eso es herencia, claramente agregandole a la clase trabajador metodos como trabajar, salario, puesto entre otra cosas pero heredan de la persona
El alcance público en programación, especialmente en TypeScript y POO, tiene desventajas como:
Es importante considerar el uso de modificadores de acceso, como privado o protegido, para mejorar la calidad y robustez del código.
Acceso Privado (private)
Es como una caja cerrada con llave:
Solo el propio objeto puede usarlo. ¡Nadie más puede tocarlo desde afuera!
class Cofre { private secreto: string = "Tesoro escondido"; mostrarSecreto() { console.log(this.secreto); // ✅ Se puede ver desde adentro }} const miCofre = new Cofre();// console.log(miCofre.secreto); // ❌ Error: es privado miCofre.mostrarSecreto(); // ✅ El cofre te muestra el secreto
Acceso Privado (private)
```js
class Cofre { private secreto: string = "Tesoro escondido"; mostrarSecreto() { console.log(this.secreto); // ✅ Se puede ver desde adentro }} const miCofre = new Cofre();// console.log(miCofre.secreto); // ❌ Error: es privado miCofre.mostrarSecreto(); // ✅ El cofre te muestra el secreto
Acceso Público (public)
Es como una puerta abierta: ¡Cualquiera puede ver o usar eso del objeto!
class Juguete {
public nombre: string = "Carro";
}
const miJuguete = new Juguete();
console.log(miJuguete.nombre); // ✅ Se puede ver
Acceso Público (public)
Es Acceso Privado (private)
como una puerta abierta:
¡Cualquiera puede ver o usar eso del objeto!
class Juguete { public nombre: string = "Carro"; } const miJuguete = new Juguete(); console.log(miJuguete.nombre); // ✅ Se puede ver
Es como una caja cerrada con llave: Solo el propio objeto puede usarlo. ¡Nadie más puede tocarlo desde afuera!
class Cofre { private secreto: string = "Tesoro escondido"; mostrarSecreto() { console.log(this.secreto); // ✅ Se puede ver desde adentro }} const miCofre = new Cofre();// console.log(miCofre.secreto); // ❌ Error: es privado miCofre.mostrarSecreto(); // ✅ El cofre te muestra el secreto
La única ventaja que tendría usar el "readonly" es para emplear propiedades o atributos constantes en las clases que estamos seguros no cambiarán su valor en el ciclo de vida de la aplicación y tampoco podrán modificarse tanto interna como externamente, es decir, solamente las usaríamos para consultas.
Modificadores de acceso
Los modificadores de acceso son fundamentales para implementar el encapsulamiento, cuyo objetivo es controlar el acceso a los datos de un objeto o instancia, protegiéndolos de modificaciones no deseadas. Estos modificadores establecen niveles de acceso a los atributos y métodos de una clase, mejorando la seguridad y la integridad de nuestras aplicaciones. Determinan cómo se pueden acceder o modificar los campos y métodos, definiendo si pueden ser accesibles desde otras partes del programa o solo dentro de la misma clase.
Los modificadores de acceso en TypeScript son:
public: El método o atributo es accesible desde cualquier parte del programa.private: Solo puede ser accedido desde dentro de la misma clase.protected: Solo es accesible desde la misma clase y las clases que heredan de ella.readonly: Se puede leer pero no modificar después de su inicialización (aunque no es un modificador de acceso, es importante mencionarlo).class NombreClase { // Atributos o propiedades public atributo1: tipo; // Atributo accesible desde cualquier parte private atributo2: tipo; // Atributo solo accesible dentro de la clase protected atributo3: tipo; // Atributo accesible en la clase y en clases derivadas // Constructor constructor(parametro1: tipo, parametro2: tipo, parametro3: tipo) { // Inicialización de atributos this.atributo1 = parametro1; this.atributo2 = parametro2; this.atributo3 = parametro3; } // Método accesible desde cualquier parte public NombreMetodo(): tipo_retorno { // Código del método } // Método solo accesible dentro de la clase private NombreMetodo(): tipo_retorno { // Código del método } // Método accesible en la clase y en clases derivadas protected NombreMetodo(): tipo_retorno { // Código del método } }
buen video nos enseña los accesos públicos que se pueden tener el un objeto
Code CLASS
export class MyDate { public year: number; month: number; day: number; constructor(year: number, month: number, day: number) { this.year = year; this.month = month; this.day = day; } printFormat(): string { return `${this.day}/${this.month}/${this.year}`; } add(amount: number, type: 'days' | 'months' | 'years') { if (type == 'days') { this.day += amount; } if (type == 'months') { this.month += amount; } if (type == 'years') { this.year += amount; } } } const myDate = new MyDate(1993, 7, 9); console.log(myDate.day); myDate.day = 12; console.log(myDate.day);
// Acceso público significa que desde que usamos la clase para instanciar y crear objetos, // tenemos acceso a sus propiedades y métodos para ejecutarlas y leerlas, respectivamente // si no se le especifica cuál tipo de propiedad es, TS deja por defecto el acceso público