Static

solo no inicializar el max

numbers.reduce((max, item) => max > item ? max : item);

Ésta ha sido mi solucion al reto…

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);
}

Infinitas formas de hacer los mismo…

  static max(...numbers: number[]) {
    return numbers.reduce((max, item) => max >= item ? max: item, -Infinity);
  }

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.

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”.

se puede iniciar con el primer valor del array

Lo hice pero primero ordené el arreglo y retorné el último elemento:

  public static max(...values: number[]): number {
    return values.sort((a, b) => a - b)[values.length - 1];
  }

class MyMath {
  static readonly PI = 3.14; // con static puedo usarlo como javascript lo usa normal, yt con readonly evito el cambio despues

  static max (...numbers: number[]) {
    console.log(numbers);
    return numbers.reduce((max, item)=> max >= item ? max: item, numbers[0]);
  }

}

initial es el primer valor del array y current el segundo, luego el reduce irá iterando y moviéndose.

static max(...numbers:number[]){
    return numbers.reduce((initial, current)=>{
      return initial >= current ? initial : current;
    });
}

console.log(MyMath.max(-5, -2, -20)) //-2

Lo resolví de la siguiente manera:

static max(...numbers: number[]) {
    return numbers.reduce((max, item) =>
      (max >= item) ? max : item,
      numbers.length == 0 ? 'Ingresa al menos un número' : -Infinity
    );
  }

Yo usé sort() para max, donde devuelvo el primer valor del nuevo array que sería el mayor, aunque reduce() es más eficiente en cuanto a rendimiento, pero sort fue lo primero que se me ocurrió:

static max(...args: number[]) {
	return args.sort((a, b) => b - a)[0];
}

Mi solucion fue esta

numbers.sort((a,b) => a - b);
return numbers[numbers.length - 1];

Mi solucion al reto:

  static max(...numbers: number[]) {
    let maxNum = numbers[0]

    for (let i = 0; i < numbers.length; i++) {
      if (numbers[i] > maxNum) {
        maxNum = numbers[i]
      }
    }
    return maxNum
  }

Paso otra forma de resolverlo, me pareció bastante ingeniosa:

static max(...numbers: number[]): number {
    try {
      numbers.sort((a: number, b: number) => {
        return b - a;
      });
    } catch {
      throw 'Error calculate max number'
    }
   return numbers[0];
  }
}

return numbers.reduce((max,item) => max >= item ? max:item);
Quitarle el punto de comparación 😃

Buenas tardes,

comparto reto:

    static max(...numbers: number[]) {
        return numbers.reduce((max, item) => max >= item ? max : item);
    }

se le quita la variable inicial ya que por defecto el toma el primer elemento del array enviado.

return numbers.reduce((max, item) => max >= item ? max : item, numbers[0]);

Asi es como hace las clases java :0

Reto

static max (...number: number[]){
        return number.reduce((max,item) => max >= item ? max: item, number[0] );
    }

mi solucion:

static max(...numbers: number[]){
        return numbers.sort((a,b)=>{return b - a})[0];
    }

Mi reto … defines el valor minimo con reduce y lo usas para el siguiente reduce.

Pero vi la solucion de Paul, es bastante mas simple aunque no entiendo como funciona el reduce a esa profundad

 max(...numbers: number[]): number {
        const minValue = numbers.reduce((min, item) => min <= item ? min : item, 0)
        return numbers.reduce((max, item) => max >= item ? max : item, minValue)
    }

El problema está en que la variable max, se está inciiando en 0, por lo que 0 siempre será mayor que cualquier número negativo. En este caso habría que iniciar la variable ya sea con el valor de la primera posición o el de la última;

profe esta mal usar otro reducer?

static max(...numbers: number[]) {
    return numbers.reduce(
      (max, item) => (max >= item ? max : item),
      numbers.reduce((a, b) => (a <= b ? a : b))
    );
  }

Una manera usando el sort

static max(...numbers: number[]) {
  return numbers.sort((a, b) => b - a)[0]
}

Mi solucion al reto

static max(...numbers: number[]) {
    return numbers.reduce((max, i) => (i > max ? i : max), numbers[0]);
}