Bueno, como prometí, ya he llegado a casa y voy a repasar los códigos de mara y west.
Veo que no hay muchos comentarios en el código. La verdad es que esta parte es muy importante porque ayuda a terceras personas a entender el algoritmo y en casos donde la clase es muy extensa, se vuelve algo indispensable, sobretodo en proyectos donde participan varias personas.
Me centraré exclusivamente en las clases que es de lo que trata el reto, los formularios es algo que tenemos más que aprendido y que domináis a la perfección.
Empezamos con la clase de mara:He visto que has publicado el código y he podido probar tu clase. Como dije, era muy importante el control de errores y en este caso he encontrado un pequeño fallo con el tema de la división por 0. Es algo en lo que solemos fallar y no basta con comprobar si el código es numérico. Dividiendo 0 / 0 obtenemos este resultado:
Warning: Division by zero in
/home/a7465051/public_html/calculadoraClass.php on line
20Veo que no has declarado las variables como privadas. Aunque no es ningún error te recomendaria por seguridad declararlas como privadas, ya que no va a ser necesario modificarlas desde fuera de la clase. También sobra la variable "$operacion", no es necesaria dentro de la clase. La variable que declares para utilizarla en la ejecución, no es necesaria declararla dentro:
<?php
private $numero1;
private $numero2;
private $resultado;
?>Has entendido muy bien cómo funcionan las funciones dentro de una clase y los métodos para realizar las operaciones están muy bien:
<?php
public function sumar($xxnumero1, $xxnumero2)
{
$this->resultado = $xxnumero1 + $xxnumero2;
return $this->resultado;
}
?>Por otro lado, no has creado un constructor y aunque no era estrictamente necesario, lo pedía para que viérais cómo funciona. En este caso sería:
<?php
function __construct()
{
$this->numero1 = 0;
$this->numero2 = 0;
$this->resultado = 0;
}
?>Te ha faltado una función que pedía para mostrar el resultado, que en este caso sería:
<?php
public function resultado()
{
echo $this->resultado;
}
?>En general, creo que has entendido bastante bien cómo funcionan las clases, aunque hubiese preferido que el control de errores fuese parte de la clase y no algo ajeno a ella, ya que el fin de las clases es reducir el código a la hora de trabajar con ellas. Me gustaría hacer otro reto un poco más difícil y ver cómo te desenvuelves con la programación orientada a objetos, seguro que lo harías bien.
Sigamos con la clase de west:Veo que tú sí has pensado en la división entre 0. Es un detalle importante y un error bastante común. En ese aspecto todo bien.
Lo que no has entendido muy bien es para qué sirve el constructor y cómo se utiliza. El constructor sirve para establecer unos valores por defecto o ejecutar cierto algoritmo al crear el objeto que hace referencia a la clase. En este caso no debías pasarle ninguna variable a la función y sobra el ($numero1 = 0, $numero2 = 0) y tampoco era necesario comprobarlas. Simplemente había que inicializar las variables:
<?php
function __construct()
{
$this->numero1 = 0;
$this->numero2 = 0;
$this->resultado = 0;
}
?>Debido al diseño de tu constructor, su función "choca" con la función numeros(), ya que hacen algo parecido y es un poco paradójico. Hay dos opciones, establecer los valores al crear el objeto (new Calculadora(5, 3)) o establecerlos utilizando un método (numeros(5, 3)). En este caso pedía hacerlo con un método y tú lo has hecho de las dos formas.
He visto que las operaciones las realiza en un mismo método y mi intención era que fuese un método por cada operación, de esta manera sería más fácil ver el funcionamiento de la clase.
El método para mostrar el resultado perfecto.
En general creo que está bastante bien teniendo en cuenta que no te hacía mucha gracia la programación orientada a objetos y sería interesante verte programar alguna clase más.
A continuación os haré un boceto de cómo tenía pensado yo este reto. No es que sea lo correcto, porque hay muchas formas de programar, pero es lo que tenía en mente y en vez de hacerlo con dos operantes, lo haré compatible con más de dos, ya que sería un poco repetitivo y así variamos un poco. Veamos qué lío me sale:
<?php
/*
Clase Calcular para PHPeros.net
Reto #4: Practicando con clases en PHP
*/
class Calcular
{
# Declaramos 3 variables
# privadas para nuestra clase.
private $operantes;
private $resultado;
private $error;
# Creamos un constructor
# que las inicialice.
function __construct()
{
$this->operantes = array(10, 5);
$this->resultado = 0;
$this->error = false;
}
# Diseñamos un método PRIVADO
# para mostrar el error que solo
# podrá ser utilizado dentro de nuestra clase.
private function verError()
{
return "Error: ".$this->error;
}
# Diseñamos un método para establecer
# los operantes y comprobar su tipo.
public function operantes($xOperantes)
{
# Creamos una variable boleana
# de control que devolverá TRUE
# en caso de que algún valor no
# sea numérico.
$xHayError = false;
# Comprobamos si los valores
# se encuentran dentro de una array.
if(is_array($xOperantes))
{
# Comprobamos si hay más de 1
# operante, lógicamente.
if(count($xOperantes) >= 2)
{
# Recorremos los valores uno a uno
foreach($xOperantes as $xNumero)
{
# Comprobamos si son del tipo numérico.
if(!is_numeric($xNumero))
{
$xHayError = true;
break;
}
}
# Comprobamos si ha habido algún error
# al recorrer el array.
if($xHayError)
{
$this->error = "Debes introducir exclusivamente valores numéricos.";
echo $this->verError();
}
else
{
$this->operantes = $xOperantes;
}
}
else
{
$this->error = "Debe haber como mínimo 2 operantes.";
echo $this->verError();
}
}
else
{
$this->error = "Para hacerlo más divertido, los operantes deben estar dentro de un array.";
echo $this->verError();
}
}
# Diseñamos un método que recorra
# el array y sume sus valores.
public function sumar()
{
# Si no ha ocurrido ningún error
# al establecer los operantes.
if(!$this->error)
{
# Inicializamos el resultado a 0.
$xResultado = 0;
# Recorremos el array y realizamos
# la operación correspondiente al método.
foreach($this->operantes as $xNumero)
{
$xResultado = $xResultado + $xNumero;
}
# Almacenamos el resultado en
# la variable global.
$this->resultado = $xResultado;
}
}
# Diseñamos un método que recorra
# el array y reste sus valores.
public function restar()
{
# Si no ha ocurrido ningún error
# al establecer los operantes.
if(!$this->error)
{
# Inicializamos el resultado con
# el doble del primer valor, de manera
# que al restar la primera vez, obtengamos
# el primer valor íntegro.
$xResultado = $this->operantes[0] * 2;
# Recorremos el array y realizamos
# la operación correspondiente al método.
foreach($this->operantes as $xNumero)
{
$xResultado = $xResultado - $xNumero;
}
# Almacenamos el resultado en
# la variable global.
$this->resultado = $xResultado;
}
}
# Diseñamos un método que recorra
# el array y multiplique sus valores.
public function multiplicar()
{
# Si no ha ocurrido ningún error
# al establecer los operantes.
if(!$this->error)
{
# Inicializamos el resultado a 1
# para que al multiplicar el primer
# operante, devuelva su valor íntegro.
$xResultado = 1;
# Recorremos el array y realizamos
# la operación correspondiente al método.
foreach($this->operantes as $xNumero)
{
$xResultado = $xResultado * $xNumero;
}
# Almacenamos el resultado en
# la variable global.
$this->resultado = $xResultado;
}
}
# Diseñamos un método que recorra
# el array y divida sus valores.
public function dividir()
{
# Creamos una variable de control
# que devolverá TRUE en case de que
# algún operante sea 0.
$xHayError = false;
# Si no ha ocurrido ningún error
# al establecer los operantes.
if(!$this->error)
{
# Inicializamos el resultado
# con el primer operante elevado
# al cuadrado, para que devuelva
# su valor íntegro.
$xResultado = $this->operantes[0] * $this->operantes[0];
# Recorremos el array y realizamos
# la operación correspondiente al método.
foreach($this->operantes as $xNumero)
{
# Comprobamos si algún
# operante es igual a 0.
if($xNumero != 0)
{
$xResultado = $xResultado / $xNumero;
}
else
{
$xHayError = true;
break;
}
}
if($xHayError)
{
$this->error = "No puedes dividir valores entre 0.";
echo $this->verError();
}
else
{
# Almacenamos el resultado en
# la variable global.
$this->resultado = $xResultado;
}
}
}
# Diseñamos un método para
# devolver el resultado.
public function verResultado()
{
# Si no ha ocurrido ningún error
# al establecer los operantes.
if(!$this->error)
{
return "El resultado es: ".$this->resultado;
}
}
}
?>De esta forma, si lo que queremos es, por ejemplo, dividir múltiples valores, su ejecución sería tan sencilla como:
<?php
$operacion = new Calcular();
$operacion->operantes(array(100, 2, 5));
$operacion->dividir();
echo $operacion->verResultado();
?>Incluye el control de errores, por lo que no es necesario comprobar nada al utilizar la clase, todo se genera desde dentro.
Os adjunto mi clase.
Gracias por vuestro interés en mi reto y espero que haya sido instructivo.
Un saludo
