Contenido del curso
Fundamentos de POO
POO Avanzada
Asincronismo y consumo de APIs
Genéricos
Próximos pasos
Static
Paul capelo
Estudiante
Miguel Angel Reyes Moreno
Estudiante
Juan David Reyes
EstudianteContenido del curso
Static
Paul capelo
EstudianteMiguel Angel Reyes Moreno
EstudianteJuan David Reyes
Estudiante
Luis Berenguer
Estudiante
Ezequiel Alejandro Barrales
Estudiante
Nicolas Molina
Profesor
Andrés Muñoz
Estudiante
Luis Angel José Portillo Arévalo
Estudiante
Diego Vergara
Estudiante
William Cortes
Estudiante
Henry Corredor
Estudiante
DANIELA PARDIÑAZ
Estudiante
Alvaro Olarte
Estudiante
César Augusto Cortés Labrada
EstudianteDANIELA PARDIÑAZ
Estudiante
Paul Francis
Estudiante
Andrés Felipe Eslava Zuluaga
Estudiante
Oscar Fuentes Esteves
Estudiante
Federico Ivan Llano
Estudiante
Daniel Schmidt
Estudiante
David Rangel
Estudiante
Jesus Juma
EstudianteJohan Sebastian
Estudiante
Jesús Patricio Pereira Matus
Estudiante
Daniel Camacho
Estudiante
Carlos Alberto Hernandez Rodriguez
Estudiante
Ellioth Aguirre Gonzales
Estudiante
Eric Daniel Cavanzo
Estudiantesolo no inicializar el max
numbers.reduce((max, item) => max > item ? max : item);
crack :up
haces la vida mas facil jaskj :3
Ésta ha sido mi solucion al reto…
Veo que se puede hacer que un attribute sea readonly y no se permita una reasignación de valor. ahora, es posible proteger la reasignación de un método? Porque veo que sea static o no, los métodos pueden reasignarse y eso sí que no está bueno.
Hola, es una gran pregunta y la respuesta es no, el readonly solo está hecho para atributos, no para métodos, pero tienes razón en que entonces podría cambiar el comportamiento de un método, por ejemplo:
class MyClass { static getName() { return 'hola'; } } console.log(MyClass.getName()); MyClass.getName = () => 'haha'; console.log(MyClass.getName());
Hay un issue en GitHub para ver si se agrega readonly tambien para los métodos.
Tal vez una forma de solucionar esto sea escribir el método como una arrow function
class myMath { static readonly PI = 3.14; static readonly calculateCircumference = (diameter: number) => { return this.PI * diameter; } }```
La solución es simplemente no pasar el segundo parametro del reduce.
El primer parametro del reduce es el callback donde se ejecuta la operación del reduce y el segundo es un parametro opcional que indica el valor inicial del acumulador, por defecto, el valor inicial del acumulador es la primera posición del array y curr empezaría desde la siguiente posición.
static max(...numbers: number[]) { return numbers.reduce((acc, curr) => acc > curr ? acc : curr); }
Lo mismo pense, ya que en si los operadores lógicos entienden de numeros positivos y negativos.
Infinitas formas de hacer los mismo....
static max(...numbers: number[]) { return numbers.reduce((max, item) => max >= item ? max: item, -Infinity); }
justo estaba buscando esta respuesta ~
Ejemplos de situaciones de la vida real donde tendríamos miembros estáticos De momento así dicho queda un tanto abstracto. Pero antes de ponerse con ejemplos concretos de programación donde hablemos de la utilidad práctica de los miembros estáticos sea bueno tratar de explicar estos conceptos un con situaciones de la vida real.
Por ejemplo, pensemos en los autobuses de tu ciudad. No sé si es el caso, pero generalmente en España todos los autobuses metropolitanos tienen la misma tarifa. Yo podría definir como un atributo de la clase AutobúsMetropolitano su precio. En condiciones normales, para acceder al precio de un autobús necesitaría instanciar un objeto autobús y luego consultar su precio. ¿Es esto práctico? quizás solo quiero saber su precio para salir de casa con dinero suficiente para pagarlo, pero en el caso de un atributo normal necesariamente debería tener instanciado un autobús para preguntar su precio.
Pensemos en el número "Pi". Sabemos que necesitamos ese número para realizar cálculos con circunferencias. Podría tener la clase Circunferencia y definir como atributo el número Pi. Sin embargo, igual necesito ese número para otra cosa, como pasar ángulos de valores de grados a radianes. En ese caso, en condiciones normales sin atributos de clase, necesitaría instanciar cualquier círculo para luego preguntarle por el valor de "Pi". De nuevo, no parece muy práctico.
Nota: Ojo, porque en el caso del número Pi, su valor será siempre constante. Podríamos en esa caso usar constantes si nuestro lenguaje las tiene, pero los atributos estáticos no tienen por qué ser siempre un valor invariable, como es el caso del precio de los AutobusesMetropolitanos, que sube cada año. Con esos tenemos dos ejemplos de situaciones en las que me pueden venir bien tener atributos "static", o de clase, porque me permitirían consultar esos datos sin necesidad de tener una instancia de un objeto de esa clase.
En cuanto a métodos, pensemos por ejemplo en la clase Fecha. Puedo intentar construir fechas con un día, un mes y un año, pero puede que no necesite una fecha en un momento dado y solo quiera saber si una fecha podría ser válida. En situaciones normales debería intentar construir esa fecha y esperar a ver si el constructor me arroja un error o si la fecha que construye es válida. Quizás sería más cómodo tener un método vinculado a la clase, en el que podría pasarle un mes, un día y un año y que me diga si son válidos o no.
Yo inicialice asi:
return numbers.reduce((max, item) => max >= item ? max: item, -Infinity);
🤪
Los miembros de una clase son las propiedades y los métodos. Cuando creamos un objeto, ese objeto realiza una copia de todos los miembros(propiedades y métodos que no sean estáticos). Los miembros estáticos sólo le pertenecen a la clase y no al objeto.
class MyMath { public static PI:number = 3.14; private static getNumber():number{ return this.PI; } } const nerd = new MyMath(); //El objeto no puede acceder a las propiedades estáticas de la clase nerd.PI //error, esta propiedad es estática //La Clase: MyMath.PI; //permite acceder a esta propiedad MyMath.getNumber(); //No puede ser accedido porque aunque es static es private
La definición formal de los elementos estáticos (o miembros de clase) nos dice que son aquellos que pertenecen a la clase, en lugar de pertenecer a un objeto en particular. Recuperando concetos básicos de orientación a objetos, sabemos que tenemos:
Clases: definiciones de elementos de un tipo homogéneo. Objetos: concreción de un ejemplar de una clase. En las clases defines que tal objeto tendrá tales atributos y tales métodos, sin embargo, para acceder a ellos o darles valores necesitas construir objetos de esa clase. Por ejemplo, una casa tendrá un número de puertas para entrar, en la clase tendrás definida que una de las características de la casa es el número de puertas, pero solo concretarás ese número cuando construyas objetos de la clase casa. Un coche tiene un color, pero en la clase solo dices que existirá un color y hasta que no construyas coches no les asignarás un color en concreto. En la clase cuadrado definirás que el cálculo del área es el "lado elevado a dos", pero para calcular el área de un cuadrado necesitas tener un objeto de esa clase y pedirle que te devuelva su área.
Ese es el comportamiento normal de los miembros de clase. Sin embargo, los elementos estáticos o miembros de clase son un poco distintos. Son elementos que existen dentro de la propia clase y para acceder los cuales no necesitamos haber creado ningún objeto de esa clase. Osea, en vez de acceder a través de un objeto, accedemos a través del nombre de la clase.
Mi solucion es esta:
static max(...numbers: number[]){ console.log(numbers); return numbers.reduce((max, item)=> max >= item ? max: item, -Infinity) }
Si reduce tiene definido un valor inicial (el segundo parámetro que recibe reduce), la función reductora va a tomar este segundo parámetro como primer argumento en la primera llamada de la función callback.
Si dejamos el 0 en nuestra función max, al ser procesado por el reduce, cuando reciba valores negativos siempre tomará dicho valor cero, pues seria el valor inicial.
class MyMath { static readonly PI = 3.14; // Static nos permite hacer un llamado de los valores dentro de la clase sin la necesidad de una instancia static max(...numbers: number[]) { return numbers.reduce( (max,item) => max >= item ? max : item ); } }
Mi respuesta, usando el último elemento en lugar del primero:
static max(...numbers: number[]) { return numbers.reduce((max, item) => max >= item ? max : item, numbers[numbers.length - 1]); }
Lo raro es que se me olvidó poner el -1 en el último arreglo, y de todas maneras funcionó, la parecer también funciona cuando el valor de comparación es "undefinded".
Lo pense de la misma forma, pensaba que no iba a funcionar pero funciono.
se puede iniciar con el primer valor del array
Jejejeje, aplicas un -Infinity como valor base en el reducer:
static max(...numbers: number[]) { return numbers.reduce((max, item) => (max >= item ? max : item), -Infinity); }
si comienza en 0, pues puedo hacer que empiece en -10
Mi solucion
class MyMath { static readonly PI = 3.14; static max(...numbers: number[]) { return numbers.reduce((max, item) => max >= item ? max: item, - Infinity); } } // MyMath.PI = 234.11; console.log('MyMath.PI', MyMath.PI); console.log('MyMath.max',MyMath.max(23,323,121,2,1,3,4)); const number = [23,323,121,2,1,3,4]; console.log('MyMath.max',MyMath.max(...number)); console.log('MyMath.max',MyMath.max(-1, -3, -5, -23));
static es simplemente que puedes usarlo sin crear una clase
porque cuando invoca el metodo que recibe el array dinamico, y le asigno el array le puso tambien los ... para enviarlo
Porque el método max(…numbers: number[]) recibe n cantidad de valores de tipo number y con el spread operator es decir “los tres puntos”, hacemos una copia de los valores del array numbers y se los pasamos como argumento al método.
La palabra static en programación, especialmente en lenguajes como TypeScript y Java, se refiere a miembros de una clase que pertenecen a la clase misma y no a instancias individuales de la clase. Esto significa que puedes acceder a estos miembros sin necesidad de crear un objeto de la clase. Los métodos y propiedades estáticas pueden ser útiles para crear utilidades o constantes que no dependen del estado de una instancia particular.
Yo utilice un doble reduce
console.log(Math.PI); console.log("Math.PI", Math.max(1,2,2,8,1,0)); class MyMath { static readonly PI = 3.14 static max (...numbers : number[]) { console.log(numbers); return numbers.reduce((max, currentNumber) => { if(max < currentNumber) { max = currentNumber } return max; }, numbers.reduce((min, currentNumber) => { if(min > currentNumber) { min = currentNumber } return min })); } } // const math = new MyMath(); // math.PI // MyMath.PI = 21313 console.log("MyMath", MyMath.PI); // const numbers = [1,23,34,4,3,234,2432,423,423,42,] // console.log(MyMath.max(...numbers)); console.log(MyMath.max(-1, -9, -8)); ```Aunque me parece curioso que cuando lo pregunte a copilot utilizo el -infinity  me parece una solucion algo logica pero no la habia pensado honestamente