Curso de Manejo de Datos en PHP
Curso de Manejo de Datos en PHP

Datos

1

Qué aprenderás sobre el manejo de datos en PHP

2

Comillas

3

Extracción de datos

4

Formato de datos

5

Expresiones regulares

6

Iniciando nuestro proyecto

7

Revisando nuestro proyecto

Funciones

8

Argumentos

9

Return

10

Closure

Arrays

11

Array simple

12

Array complejo

13

Funciones PHP para arrays

14

Comparación

15

Unión

16

Resumen final

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Crear cuenta

Si ya tienes una cuenta,

Iniciar sesión
Curso de Manejo de Datos en PHP

Curso de Manejo de Datos en PHP

Italo Morales F

Italo Morales F

Revisando nuestro proyecto

7/16
Recursos

Aportes 93

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Cristian Dario Bastos

Cristian Dario Bastos

hace 2 años

Validate.php
– le indicamos que permite números, letras mayúsculas y minúsculas, entre 6 y 9 caracteres si, no cumple esa regla, dará falso

    public static function password($value)
    {
        return (bool) preg_match('/^[0-9a-zA-Z]{6,9}$/',$value);
    }

ValidateTest.php

    public function test_password()
    {
        $password  = Validate::password('Abc1234VS');
        $this->assertTrue($password);

        $password  = Validate::password('Abc1w');
        $this->assertFalse($password);
    }
RetaxMaster

RetaxMaster

Profe Platzi

hace 2 años

De hecho prácticamente lo que hace PHP Unit es crear pequeños casos de pruebas y dejarlos programados para testearlos siempre, así puedes usar tus clases sin preocupación, literal te está ahorrando el trabajo de ir a navegador y poner los datos de prueba tu mismo para empezar a depurar jaja

Jorge Leonardo Cárdenas Montenegro

Jorge Leonardo Cárdenas Montenegro

hace 2 años

Reto cumplido!

La expresión regular /^(?=.\d)(?=.[\u0021-\u002b\u003c-\u0040])(?=.[A-Z])(?=.[a-z])\S{8,16}$/ significa:
La contraseña debe tener al entre 8 y 16 caracteres, al menos un dígito, al menos una minúscula y al menos una mayúscula. Puede tener otros símbolos.
Es importante resaltar que existen 2 tipos de filtros, uno de validación y otro de saneamiento como los podemos ver en https://www.php.net/manual/es/filter.filters.php

Edgar Ramón González Contreras

Edgar Ramón González Contreras

hace 2 años

Para Password lo que hice fue utilizar el método password_hash() y PASSWORD_BCRYPT. Quedando de la siguiente manera:

Validate.php

public static function password($value){
    return (bool) password_hash($value, PASSWORD_BCRYPT);
  }

ValidateTest.php

public function test_password(){
    $password = Validate::password('1234567');
    $this->assertTrue($password);
  }

Jalando y funcionando 😃

Geovanny Lacayo

Geovanny Lacayo

hace 2 años

Validar un password con mínimo ocho caracteres, al menos una letra mayúscula, una letra minúscula, un número y un carácter especial:

Validate.php

    public static function password($value)
    {
        return (bool) preg_match('/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&]{8,}$/', $value);
    }

ValidateTest.php

    public function test_password()
    {
        $password = Validate::password('Contrasena2020*');
        $this->assertTrue($password);

        $password = Validate::password('Contrasena');
        $this->assertFalse($password);
    }
Gabriel Rodriguez

Gabriel Rodriguez

hace un año

La pedagogía de Italo y la paciencia con la que explica le da un plus enorme a sus cursos.

ettorestark

ettorestark

hace 2 años

Si desean profundizar un poco más les deseo leer sobre TDD (Test Driven Development). Es una metodología que nos permite desarrollar en base a nuestras pruebas.

Kenet Andrés Chungandro Montenegro

Kenet Andrés Chungandro Montenegro

hace 2 años
Jonathan Emmanuel Pumares Chab

Jonathan Emmanuel Pumares Chab

hace 7 meses

Podemos crear un alias para no tener que escribir toda la ruta hacia el ejecutable de phpunit:

alias t="vendor/phpunit/phpunit/phpunit"
Christian Vargas

Christian Vargas

hace 9 meses

Se me voló la cabeza 🤯, antes de iniciar esta carrera de php hice un curso básico de php e hice un proyecto con programación estructurada, realmente me costo hacerlo y cree un código espagueti horrible pero viendo como funciona phpunit todo esto cambia, no puedo esperar Laravel.

ValidateTest.php

Creé un test para validar el password y pruebo lo siguiente:

  • números
  • usando números y letras minúsculas
  • números con letras minúsculas y mayúsculas
public function test_password()
    {
        $url = Validate::password('123456');
        $this->assertTrue($url);

        $url = Validate::password('12345');
        $this->assertFalse($url);

        $url = Validate::password('123456789');
        $this->assertTrue($url);

        $url = Validate::password('1234567890');
        $this->assertFalse($url);

        $url = Validate::password('123dsfasd');
        $this->assertTrue($url);

        $url = Validate::password('123dsfasda');
        $this->assertFalse($url);

        $url = Validate::password('123ADfasd');
        $this->assertTrue($url);

        $url = Validate::password('123dsfaADFsda');
        $this->assertFalse($url);
    }

ValidateTest.php

Creé una expresión regular que permita números, letras minúsculas y mayusculas, limitando sus caracteres entre 6 y 9.

public static function password($value)
    {
        return (bool)preg_match('/^[0-9a-zA-Z]{6,9}$/', $value);
    }
Gabriel Andrés Rondón Barragán

Gabriel Andrés Rondón Barragán

hace 10 meses

Acá mi solución al reto:
En ValidateTest.php:

public function test_password() //probar la url con la clase Validate
    {
        $pass = Validate::password('123456');
        $this-> assertTrue($pass);

        $pass = Validate::password('12345');
        $this-> assertFalse($pass);
        
        $pass = Validate::password('A123456');
        $this-> assertFalse($pass);
    }

en Validate.php:

public static function password($value)
    {
       return (bool) filter_var($value,FILTER_VALIDATE_REGEXP,array(
        "options" => array("regexp"=>"/^[0-9]{6,9}$/")
   ));
    }

En este caso, revisando la documentación de los FILTER_VALIDATE, vi que existe el FILTER_VALIDATE_REGEXP y se debe usar con un array de esa forma.
Por último, en mi index.php:

$VALIDATION_PASS= App\Validate::password('87289a');

if ($VALIDATION_PASS === true){
    echo "Su contraseña es válida <br>";
}
else{
    echo 'Su contraseña no cumple con los requisitos <br>';
}
Weoka ‎

Weoka ‎

hace 2 años

Reto:
Validate.php:

<?php

namespace App;

class Validate
{
    public static function password($value)
    {
        return (boolean) preg_match('/^[0-9]{3,9}$/',$value);
    }
}

ValidateTest.php:

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function test_pass()
    {
        $pass = Validate::password('123456');
        $this->assertTrue($pass);
    }
}
Elliot Aristeo Urizar Rodas

Elliot Aristeo Urizar Rodas

hace 4 días

ValidateTest.php

public function test_password()
    {
        $password = Validate::password('asdfas');
        $this->assertTrue($password);
        $password = Validate::password('as2sdf2');
        $this->assertFalse($password);
    }

Validade.php

public static function password($value){
        return (bool) preg_match('/^[a-z]{6,9}$/', $value);
    }
Andres Jimenez

Andres Jimenez

hace 2 meses

El metodo a validar:

public static function passwd($value)
    {
        return (bool) preg_match('/^[A-Za-z0-9\[email protected]$!%*?&]{6,12}$/', $value);
    }

El metodo que valida:

public function test_passwd()
    {
        $passwd = Validate::passwd('Lerolero78?*');
        $this->assertTrue($passwd);

        $passwd = Validate::passwd('An8=n');
        $this->assertFalse($passwd);
    }
José Alberto Ramírez Quiroz

José Alberto Ramírez Quiroz

hace 2 meses

Que saltos cuanticos tan feos da el profe…

Parare mi aprendizaje en este curso hasta aqui vengo en el futuro a retomarlo 😦

Nicolás Rodríguez Álvarez

Nicolás Rodríguez Álvarez

hace 3 meses

Buenas! Comparto mi resolución al reto. Saludos!

ValidateTest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;


class ValidateTest extends TestCase
{   
    //comprobamos si un email es correcto
    public function test_email()
    {
        $email = Validate::email('[email protected]');
        $this->assertTrue($email);
    }
    //comprobamos si existe una url
    public function test_url()
    {
        $url = Validate::url('https://platzi.com');
        $this->assertTrue($url);
    }
    //comprobamos si una password cumple con una expresión
    public function test_password()
    {
        $password = Validate::password('1234567');
        $this->assertTrue($password);
    }
}

Validate.php

<?php

namespace App;

class Validate 
{
    public static function email($value)
    {
        return (bool) filter_var($value, FILTER_VALIDATE_EMAIL);
    }

    public static function url($value)
    {
        return (bool) filter_var($value, FILTER_VALIDATE_URL);
    }

    public static function password($value)
    {
         
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }
    
}

Resultado de la prueba

Saul Juarez

Saul Juarez

hace 4 meses
Diego Dominguez

Diego Dominguez

hace 4 meses

Ahh, ahora entendí estaba re perdido en la clase anterior

Erick Alejandro Graterol Barico

Erick Alejandro Graterol Barico

hace 4 meses
Creo que se podria validar tablas o funciones hacia bases de datos, una funcion para obtener un formulario la verdad es muy util y interesante esto de los test
Julio Caicedo

Julio Caicedo

hace 4 meses
ValidateTest

public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);
        $password = Validate::password('12s3456');
        $this->assertFalse($password);
    }

Validate

    public static function password($pass)
    {
        return (bool)preg_match('/^[0-9]{6,9}$/',$pass);
    }
Jean Mercedes

Jean Mercedes

hace 5 meses

ValidateTest.php

    public function test_pass() {
        $email = Validate::pass('123456');
        $this->assertTrue($email);

        $email = Validate::pass('1234567890');
        $this->assertFalse($email);

        $email = Validate::pass('123456a');
        $this->assertFalse($email);
    }

Validate.php

    public static function pass($var) {
        return (bool) preg_match('/^[0-9]{6,9}$/', $var);;
    }
Jose Alexis Vazquez Morales

Jose Alexis Vazquez Morales

hace 5 meses


Juan Camilo Salazar Gañan

Juan Camilo Salazar Gañan

hace 6 meses

Despues de tanto luchar con la version de php, este es el reto:

public static function password($value)
{
	return (bool) preg_match('/^[0-9]{6,9}$/', $value);
 }

public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);
        $password = Validate::password('123456a');
        $this->assertFalse($password);
    }
Juan Antonio Cuahonte Isla

Juan Antonio Cuahonte Isla

hace 6 meses

RETO

Test

public function test_password(){
        $password = Validate::password('Ax%2090-45');
        $this->assertTrue($password);
        
        
        $password = Validate::password('ax%2090-');
        $this->assertFalse($password);
    }

Function

 public static function password($value){
        return (bool) preg_match("/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&-]{8,}$/",$value);
    }
Juan camilo piedrahita londoño

Juan camilo piedrahita londoño

hace 6 meses

Buen curso

Julian David Alzate Cuervo

Julian David Alzate Cuervo

hace 7 meses

Esta clase esta genial, nunca había usado composer y aquí veo mucha utilidad

Jose Alvaro Japa Salazar

Jose Alvaro Japa Salazar

hace 7 meses

Reto cumplido 😄

Pedro Alberto Esparza Garza

Pedro Alberto Esparza Garza

hace 7 meses

Escribe en terminal

php .\vendor\phpunit\phpunit\phpunit --testdox

ValidateTest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function testEmailHasTheCorrectFormat()
    {
        $this->assertTrue(Validate::email('[email protected]'));

        $this->assertFalse(Validate::email('[email protected]@gmail.com'));
    }

    public function testUrlHasTheCorrectFormat()
    {
        $this->assertTrue(Validate::url('https://sistenet.mx'));

        $this->assertFalse(Validate::url('sistenet.mx'));
    }

    public function testPasswordHasTheCorrectFormat()
    {
        $this->assertTrue(Validate::password('A1B2C3D4E5'));

        $this->assertFalse(Validate::password('@#[email protected]#asda.0a.a0sda.sd'));
    }
}
Cristian Andres Ladino Peña

Cristian Andres Ladino Peña

hace 8 meses

Lo logré! 😁

En el archivo “Validate.php”, agregué el siguiente método:

    public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

Y en el “ValidateTest.php” agregué esta función:

    public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);

        $password = Validate::password('12345e6');
        $this->assertFalse($password);
    }

Funciona! 🔥

David Monsalvo

David Monsalvo

hace 8 meses
  public static function pass($value)
  {
    return (bool) preg_match('/^[0-9a-z]{6,9}$/', $value);
  }


  public function password()
  {
    $pass = Validate::pass('');
    $this->assertIsBool($pass);
  }

var_dump(App\Validate::pass('123456'));
José Roberto Arroyo García

José Roberto Arroyo García

hace 8 meses

Les comparto el ejercicio de validar contraseña con las siguientes reglas:

  • Debe tener al menos 8 caracteres.
  • Debe tener al menos una mayúscula.
  • Debe tener al menos un número.
  • Debe tener uno de los siguientes símbolos: [email protected]$!%*#?&_
#Validate.php
public static function password($value) {
        return (bool)  preg_match('/^(?=.*[A-Za-z])(?=.*[@$!%*#?&_])[A-Za-z\[email protected]$!%*#?&_]{8,}$/', $value);
    }

#ValidateTest.php
public function test_password() {
        $password = Validate::password('Platzi#2021');
        $this->assertTrue($password);

        $password = Validate::password('platzi');
        $this->assertFalse($password);
    }
Cristian Castro

Cristian Castro

hace 8 meses

Este sería el método en la clase Validación.
Spoiler: Añadí alguna modificación al tipo de password para que aceptara letras en mayusculas y minusculas.

public static function password($value){
        return (bool) preg_match('/^[0-9,a-z,A-Z]{6,9}$/', $value);
    }

Y este sería el método de Test

public function test_password(){
        $pass = Validacion::password('12345670');
        $this->assertTrue($pass);

        $pass = Validacion::password('1P3z45Aj');
        $this->assertTrue($pass);

        $pass = Validacion::password('1234');
        $this->assertFalse($pass);

        $pass = Validacion::password('a124Z');
        $this->assertFalse($pass);

    }
Pedro Roberto Capriles Morales

Pedro Roberto Capriles Morales

hace 10 meses

Respuesta al reto
Test del Validate

Ricardo Rito Anguiano

Ricardo Rito Anguiano

hace 10 meses

Este profe deberia hacer mas cursooooooos, estoy tomando PHP porque me lo piden en la uni, me encantaria verlo en cursos de mi interes jasajs

src/validate

    public static function Password(string $value): bool
    {
        $pattern = '/^[0-9]{6,9}$/';
        return ((bool)preg_match($pattern, $value));
    }

tests/ValidateTest

    public function test_pass()
    {
        $pass = Validate::Password('4541457');
        $this->assertTrue($pass);

        $pass = Validate::Password('4541a');
        $this->assertFalse($pass);

        $pass = Validate::Password('744541a');
        $this->assertFalse($pass);


    }
Jose Gonzalo Cortez Maldonado

Jose Gonzalo Cortez Maldonado

hace un año

En el reto me surgió una duda de que pasa si coloco espacios en un password y al poner lo simplemente no los tomaba en cuenta alguien podría explicarme a que se debe esto?, a pesar que restringía el uso a solo números el espacio no se tomaba en cuenta.

Jose Gonzalo Cortez Maldonado

Jose Gonzalo Cortez Maldonado

hace un año
public function test_pasword()
{
    $password = Validate::password_verify('0123456789','/^[::digit::]$/');
    $this->assertTrue($password);
    $url = Validate::url('[email protected]','/^[::digit::][::upper::][::lower::][::punct::]$/');
    $this->assertTrue($password);
    $url = Validate::url('[email protected]','/^[0-9][Aa-Zz]{6,30}$/');
    $this->assertTrue($password);

}
Sergio Antonio Ochoa Martinez

Sergio Antonio Ochoa Martinez

hace un año

validar password

<?php

namespace App;

class Validate {

	public static function validateEmail($email) {
		return (bool)filter_var($email, FILTER_VALIDATE_EMAIL);
	}

	public static function validateUrl($url) {
		return (bool)filter_var($url, FILTER_VALIDATE_URL);
	}

	public static function validatePassword($password) {
		return (bool)preg_match('/^[0-9]{6,9}$/', $password);
	}
}
Luis Mendoza

Luis Mendoza

hace un año

como la exoresion regular hace varias validaciones hago un test para cada una de ellas

class ValidaTest:

public function test_password()
    {

        $password = Validate::password(435876);
        $this->assertTrue($password);

        $password = Validate::password('435876');
        $this->assertTrue($password);

        $password = Validate::password('435876a');
        $this->assertFalse($password);

        $password = Validate::password(987987435876);
        $this->assertFalse($password);

        $password = Validate::password(98798);
        $this->assertFalse($password);
    }

class Validate:

public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/',$value);

    }
José Alberto Ortiz Vargas

José Alberto Ortiz Vargas

hace un año

Podemos decir que un metodo solo puede tener dos asesriones (verdadero/falso)? O existen otro tipo de asersiones que se puedan implementar?

Oscar Alejandro Fajardo Repizo

Oscar Alejandro Fajardo Repizo

hace un año

Para el archivo validate.php

  • Se indica que se va pasar una regexp que permite letras minúsculas, mayúsculas y puntos. además de que debe ser de mínimo 8 y máximo 9 caracteres si cumple la regla devolverá true si entonces será false.
public static function password($value) {
        $regexp = '/^[0-9a-zA-Z.]{8,15}/';
        $options = ['options' => [
		'regexp' => $regexp
	]];
        return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, $options);
    }

Según la documentación https://www.php.net/manual/es/function.filter-var.php si el filtro permite opciones entonces se las pasaremos como un array bidimensional.

Archivo validateTest.php

public function test_password(){

        $password = Validate::password('testpass9.');
        $this->assertTrue($password);

        $password = Validate::password('1234567');
        $this->assertFalse($password);
    }
Freddy Rafael Peñalver Nuñez

Freddy Rafael Peñalver Nuñez

hace un año

En el archivo Validate

/**
     * La contraseña debe tener al entre 8 y 16 caracteres, al menos un dígito, 
     * al menos una minúscula y al menos una mayúscula.
     * NO puede tener otros símbolos.
     */
    public static function password($value){
        return (bool) preg_match('/^(?=\w*\d)(?=\w*[A-Z])(?=\w*[a-z])\S{8,16}$/', $value);
    }

En el archivo ValidateTest

public function test_password()
    {
        $pass = Validate::password("Reto1Cumplido");
        $this->assertTrue($pass);
        
        $pass = Validate::password("cumplido");
        $this->assertFalse($pass);
    }
Cesar Eduardo Hernandez Rojas

Cesar Eduardo Hernandez Rojas

hace 2 años

Validate.php

    public static function password($value){
        return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>"/^[0-9]{6}[a-z]{2}$/")));
    }

ValidateTest.php

    public function test_password(){
        $url = Validate::password('123456ab');
        $this->assertTrue($url);
        $url = Validate::password('12345678');
        $this->assertFalse($url);
    }```
Cesar Eduardo Hernandez Rojas

Cesar Eduardo Hernandez Rojas

hace 2 años

Siguiendo el ejemplo de la funcion filter_var() y sus banderas:
Validate.php
<code>
public static function password($value){
return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, array(“options”=>array(“regexp”=>"/^[0-9]{6}[a-z]{2}$/")));
}
</code>

y el test:
ValidateTest.php
<code>
public function test_password(){
$url = Validate::password(‘123456ab’);
$this->assertTrue($url);
$url = Validate::password(‘12345678’);
$this->assertFalse($url);
}
</code>

Emerson Cedeño

Emerson Cedeño

hace 2 años

y por qué en lugar de ejecutar vendor/phpunit/phpunit/phpunit, no ejecutar mejor:

vendor/bin/phpunit
reklaw

El filtro es:

class Validate
{
    public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/',$value);
    }
}

Ahora testeamos:

public function test_password()
    {
        $password = Validate::password('123456855');
        $this->assertTrue($password);
    }
Martín Campos

Martín Campos

hace 2 años
    public static function password($value)
    {
        return (bool)  preg_match('/^[0-9]{6,9}$/', $value);
    }
Clinton Cardenas

Clinton Cardenas

hace 2 años

TEST

public function test_password()
        {
            $password = Validate::password('123221sdaA');
            $this->assertTrue($password);

            $password = Validate::password('123');
            $this->assertFalse($password);
        }

VALIDATE

public static function password($value)
    {
        return (bool) preg_match('/^[0-9a-zA-Z]{8,256}$/',$value);
    }
Jimmy Buriticá Londoño

Jimmy Buriticá Londoño

hace 2 años

Me gustan estas buenas practicas.

Mauricio Galvez

Mauricio Galvez

hace 2 años
<h3>Solucion al reto</h3> 
    public static function password( $value )
    {
        return (bool) preg_match( '/^[A-Za-z0-9]{8,15}$/', $value );
    }

    public function test_password()
    {
        $password = Validate::password('45353gfgre');
        $this->assertTrue( $password );

        $password = Validate::password('erw434');
        $this->assertFalse( $password );
    }
Sixto Ortega

Sixto Ortega

hace 2 años

Se valida el codigo desarrollado respaldado con las pruebas

Sixto Ortega

Sixto Ortega

hace 2 años

Excelente

Danny Velásquez

Danny Velásquez

hace 2 años

validate.php

<?php

namespace App;

class Validate{
	public static function password($value){
		return (bool) preg_match('/^[0-9]{6,9}$/', $value);
	}
}

validatetest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase{
	public function test_password(){
		$password = Validate::password('1234567');
		$this->assertTrue($password);

		$password = Validate::password('1234');
		$this->assertFalse($password);

	}
}

index.php

<?php

require __DIR__ . '/vendor/autoload.php';

var_dump(App\Validate::password('12345'));
Vicente Alberto Benavides Alcivar

Vicente Alberto Benavides Alcivar

hace 2 años

Validate.php

  public static function password($value) {
    return (bool) preg_match('/^[0-9]{6,9}$/', $value);
  }

ValidateTest.php

  public function test_password() {
    $password = Validate::password('123456789');
    $this->assertTrue($password);

    $password = Validate::password('123gfdg89');
    $this->assertFalse($password);
  }
Leonardo Hernández

Leonardo Hernández

hace 2 años

Muy buena explicación. Ahora me entero la gran utilidad de hacer pruebas durante la implementación de nuevo código y mantenimiento. Muchas gracias!

edwar enrique vilchez serrano

edwar enrique vilchez serrano

hace 2 años

Al momento de realizar la prueba de la URL me despliega error ![](
Espero de su apoyo por favor

edwar enrique vilchez serrano

edwar enrique vilchez serrano

hace 2 años

![](

edwar enrique vilchez serrano

edwar enrique vilchez serrano

hace 2 años
IRIDIAN GUADALUPE CARRERA MONDRAGÓN

IRIDIAN GUADALUPE CARRERA MONDRAGÓN

hace 2 años

Validatetest.php

//VALIDA LAS CONTRASENAS
    public function test_contrasenias ()
    {
        //verdadero 
        $contrasenias = Validate::contrasenias('123456789');
        $this->assertTrue($contrasenias);
        //falso
        $contrasenias = Validate::contrasenias('1sas');
        $this->assertFalse($contrasenias);       
    }

Validate.php

public static function contrasenias($value) 
    {
        return(bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

index.php


//para probar las contrasenias
var_dump(App\Validate::contrasenias('12345678')); //verdadero
var_dump(App\Validate::url('sdwew456'));  //falso
edwar enrique vilchez serrano

edwar enrique vilchez serrano

hace 2 años

Resumen de Clase y Solución al reto

![](

Cristian Josue Hernandez Amaya

Cristian Josue Hernandez Amaya

hace 2 años

ValidateTest.php
public function test_password()
{
$password = Validate::password(‘Tbcronk123456’);
$this->assertTrue($password);
}

Validate.php
public static function password($value)
{
return (bool) preg_match(’/^[a-zA-Z0-9]{10,35}$/’, $value);
}

MARCO ANTONIO ASPEITIA PEÑA

MARCO ANTONIO ASPEITIA PEÑA

hace un año

Hola comunidad, les recomiendo utilizar expresiones regulares que ya han sido creadas en internet, sólo las llevan después al código y vean si funcionan con phpunit.

Les comparto mi prueba de validación de contraseñas en el archivo Validate.php

public static function password($value)
    {
        return (bool) preg_match('/^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[a-zA-Z]).{8,16}$/', $value);;
    }

El test en ValidateTest.php

public function test_password()
    {
        $password = Validate::password('sTestkj90820');
        $this->assertTrue($password);

        $password = Validate::password('sTestkj9089320821');
        $this->assertFalse($password);
    }
José Darío Bedoya Ortiz

José Darío Bedoya Ortiz

hace un año

Reto cumplido:
Validate.php
<?php

namespace App;

class Validate{

public static function email($email){
  return (bool) filter_var($email,FILTER_VALIDATE_EMAIL);
}

public static function valpass($pass){
  return (bool) preg_match('/^[0-9]{6,9}$/',$pass); 
  
}

}

ValidateTest.php
<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase{
public function test_email(){

$email=Validate::email('[email protected]');  
$this->assertTrue($email);  

$email=Validate::email('[email protected]@gmail.com');  
$this->assertFalse($email); 

$pa=Validate::valpass('12345690');  
$this->assertTrue($pa);  

$pa=Validate::valpass('--sdlfmkasldk');  
$this->assertFalse($pa);

}
}

Omar Medrano Sarabia

Omar Medrano Sarabia

hace un año

En el archivo Validate.php

La contraseña puede contener:

  • Números.
  • Letras de la ‘a’ a la ‘z’.
  • Letras de la ‘A’ a la ‘Z’.
  • Los caracteres ‘#’ y ‘_’
  • Con un mínimo de 6 caracteres y un máximo indefinido.

No se permiten espacios en blanco.

public static function password($value)
    {
        
        return (bool) preg_match('/^[0-9a-zA-Z_#}]{6,}$/',$value);
    }

En el archivo ValidateTest.php se llama a la función

public function test_password(){
    
        $password = Validate::password('3lon_Musk#1234');
        $this->assertTrue($password);
        $password = Validate::password('3lon _Musk#1234');
        $this->assertFalse($password);
    }
Oscar Aguilar López

Oscar Aguilar López

hace un año

Mi solución al reto:
Validate.php

public static function password($value)
    {
	# Usando la expresion regular del video de expresiones regulares
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

ValidateTest.php

public function test_password()
    {
	# Usando una contraseña correcta
        $password = Validate::password('0123456');
        $this->assertTrue($password);

        # Usando una contraseña incorrecta
        $password = Validate::password('0123456A');
        $this->assertFalse($password);
    }

Y el resultado seria:

José Alberto Ortiz Vargas

José Alberto Ortiz Vargas

hace un año

Si el test falso, resultas ser verdadero, les mandara un error de que no puede retornar un faslo cuando es verdadero:

Failed asserting that true is false
Michael Camelo

Michael Camelo

hace un año

vale creo que ya todo el mundo lo hizo peroigualmente lo subo jajaja

<?php

namespace App;

class Validate
{
    public static function email($value){
        return (bool)filter_var($value, FILTER_VALIDATE_EMAIL);
    }
    public static function url($value){
        return (bool)filter_var($value, FILTER_VALIDATE_URL);
    }
    public static function password($value){
        return (bool)preg_match('/^(?=\w*\d)(?=\w*[A-Z])(?=\w*[a-z])\S{8,16}$/',$value); //expresion regular para determinar si la contraseña tiene letra mayuscula, minuscula y caracteres especiales
    }
}

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function test_email(){
        $email = Validate::email('[email protected]');
        $this->assertTrue($email);
        $email = Validate::email('[email protected]@rimorsoft.com');
        $this->assertFalse($email);
    }
    public function test_url(){
        $url = Validate::url('https://platzi.com');
        $this->assertTrue($url);
        $url = Validate::url('platzi.com');
        $this->assertFalse($url);
    }

    public function test_password(){
        $password = Validate::password('abcdefg');
        $this->assertFalse($password);
        $password = Validate::password('Adfgg122*');
        $this->assertTrue($password);
    }

}
Hernán Arica

Hernán Arica

hace un año

Dato
Para los que les resulte un poco engorroso colocar el namespace\Clase en una misma línea pueden hacer uso de la palabra use con esto podrán directamente llamar a Validate por ejemplo: use App\Validate y luego al invocar la clase hacerlo con Validate simplemente, el use siempre va ubicado arriba de todo, adjunto un ejemplo:
![](

Cristobal Nyram

Cristobal Nyram

hace un año

La magia de composer radica en que podemos cargar clases de manera automatica pero para ello tenemos que configurarlo

Jairo Jair Jasón Pozo Pérez

Jairo Jair Jasón Pozo Pérez

hace un año

Aquí mi reto!

VALIDATE.PHP

    public static function password($value){
        return (bool) preg_match('/^[0-9]{5,9}$/',$value);
    }

TEST

    public function test_password(){
        $password =Validate::password('12345');
        $this->assertTrue($password);

        $password =Validate::password('12344eA');
        $this->assertFalse($password);
    }
Juan Felipe Arias Trullo

Juan Felipe Arias Trullo

hace un año
public static function password($value)
    {
        //var_dump((bool) preg_match('/^[0-9]{6,9}$/', $password));
        return (bool) preg_match('/^[A-Za-z0-9]{6}$/', $value);
    }```
Javier Amaya Patricio

Javier Amaya Patricio

hace un año

Desafío Realizado Profesor 🏁

Creación de la función para validar la contraseña

Creación del test para el password dentro de mi archivo ValidateTest

Resultado al correr las pruebas de phpunit

Alexander Reyes

Alexander Reyes

hace un año

Challenge Complete

Configuración de composer.json

Configuración de phpunit.xml

Archivo de Test de Validación

Archivo de Lógica de Validación

Archivo de Prueba en el Servidor

David Santiago Pinchao Ortiz

David Santiago Pinchao Ortiz

hace un año

Mi propuesta, de minimo ocho caracteres y valores alfa numericos

public static function password($value)
    {
        return (bool) preg_match('/\w{8}$/', $value);
    }
Juan Sebastián Villegas Jaramillo

Juan Sebastián Villegas Jaramillo

hace un año

ValidateTest.php

    public function test_password()
    {
        $password = Validate::password('aB$1efgh');
        $this->assertTrue($password);

        $password = Validate::password('asbcdFGHI123');
        $this->assertFalse($password);

        $password = Validate::password('asbcdFGHI12*3');
        $this->assertTrue($password);

        $password = Validate::password('aSbcdFGHI123$a$24');
        $this->assertFalse($password);
    }```

Validate.php

public static function password($value)
{
$regex = “/^(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[[email protected]$!%?&])([A-Za-z\[email protected]$!%?&]|[^ ]){8,15}$/”;
return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, [“options”=>[“regexp”=>$regex]]);
}
}
Jose Montenegro

Jose Montenegro

hace un año
Héctor Tello

Héctor Tello

hace un año

Mi solución al reto:

// Archivo ValidateTest.php
  public function test_password() {
    $password = Validate::password('12341234');
    $this->assertTrue($password);
  }

// Archivo Validate.php
  public static function password($value) {
    return (bool) preg_match('/^[0-9]{6,9}$/', $value);
  }
alcaen
// ValidateTest.php

   public function test_password()
    {
        $pass = Validate::password('a23456');
        $this->assertFalse($pass);
    }


// Validate.php

  public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }
Mariano Navarrete

Mariano Navarrete

hace un año

Archivo Validate.php

public static function password($password){
        return (bool) preg_match('/^[A-Za-z0-9]+$/',$password);
    }

Archivo ValidateTest.php

public function test_password(){
        $userPassword = 'pass1234';
        $password = Validate::password($userPassword);
        $this->assertTrue($password);
    }
JonathanOrtizVilca

JonathanOrtizVilca

hace un año

Reto: Validar la contraseña

Archivo: Validate.php

public static function password($value)
    {
        return (bool)preg_match('/^[0-9]{6,9}$/',$value);
    }

Archivo: ValidateTest.php

public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);
    }

Si desean probarlo en el navegador sería:

Archivo: index.php

var_dump(App\Validate::password('123456')); //Verdadero o True
var_dump(App\Validate::password('1234')); //Falso o False
Alejandro Orosco Montaño

Alejandro Orosco Montaño

hace un año
<?php
///Validate.php
public static function password($value)
    {
    	/**
    	* Minimo 8 caracteres
		* Maximo 15
		* Al menos una letra mayúscula
		* Al menos una letra minucula
		* Al menos un dígito
		* No espacios en blanco
		* Al menos 1 caracter especial
    	*
    	*/
        return (bool) preg_match(' /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[[email protected]$!%*?&])[A-Za-z\[email protected]$!%*?&]{8,15}/',$value);
    }

/// ValidateTest.php
public function test_password()
    {
        $password  = Validate::password('Abc1234VS');
        $this->assertTrue($password);

        $password  = Validate::password('Abc1w');
        $this->assertFalse($password);
    }```
Alejandro Orosco Montaño

Alejandro Orosco Montaño

hace un año
$course ='php';
function cv(&$course = 'laravel') /// cuando usamos & en variables damos acceso
{
    $course = 'arduino';
}
cv($course);
echo "curso = $course";
///devolvera arduino!!!
Andrés Garzón Vesga

Andrés Garzón Vesga

hace un año

Validate.php

public static function password($value)
    {
        $clave = '/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[[email protected]$!%*?&])([A-Za-z\[email protected]$!%*?&]|[^ ]){8,15}$/';
        return (bool) preg_match($clave, $value);
    }
}```
Enrique Alfredo Mejias del Valle

Enrique Alfredo Mejias del Valle

hace un año

Esta es otra forma de nombrar los test.
Intentando siempre ser lo mas descriptivos posibles, así, si otro programador lee nuestro codigo entra más rapido en contexto de lo que se pretende obtener en el test.

	/**
    	 * @test
     	*/
    	public function it_is_a_valid_email()
	{
	
	}
Jorge Ramírez Santiago

Jorge Ramírez Santiago

hace un año

ValidateTest.php
![](
Validate.php

Index.php

alesweb

En Validate.php
// De 0 al 9, letras mayúsculas y minúsculas
// De 6 a 12 caracteres

public static function pass($value) {
	return (bool) preg_match('/^[0-9a-zA-Z]{6,12}$/',$value);
}

En ValidateTest.php

public function test_pass() {
	$pass = Validate::pass('Prueba1pass');
	$this->assertTrue($pass);
}

O también podriamos hacerlo así:

public function test_pass() {
	$pass = Validate::pass('Prueba1pass');
	$this->assertTrue($pass);

	$pass = Validate::pass('Prueba*1pass');
	$this->assertFalse($pass);
}
Agustin Garcia

Agustin Garcia

hace un año
Reto completado con éxito
Luis Rodriguez

Luis Rodriguez

hace un año

bueno algo simple

 public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

y en el test

public function test_password()
    {
        $password = Validate::password('Libertad123');
        $this->assertFalse($password);

        $password = Validate::password('12345678');
        $this->assertTrue($password);
    }
Noelia Walter

Noelia Walter

hace un año

Aporte

Código utilizado en el terminal

./vendor/bin/phpunit --testdox  tests

Codigo utilizado en las pruebas
ValidateTest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function testCorrectEmail() : void
    {
        $email = Validate::email('[email protected]');
        $this->assertTrue($email);

    }
    public function testDoubleArrobaEmail() : void
    {
        $email = Validate::email('[email protected]@rimorsoft.com');
        $this->assertFalse($email);
    }
}
Cristhian Coaquira

Cristhian Coaquira

hace 2 años
public static function password(string $password) : bool
    {
        return (bool)preg_match(
            '/^(?=(.*[a-z]){3,})(?=(.*[A-Z]){2,})(?=(.*[0-9]){2,})(?=(.*[[email protected]#$%^&*()\-__+.]){1,}).{8,}$/', 
            $password);
    }

public function testPassword()
    {
        $result = Validate::password('PassWord#123');
        $this->assertTrue($result);

        $result = Validate::password('Password123');
        $this->assertFalse($result);
    }
Julian Carelli

Julian Carelli

hace 2 años

Me encanto trabajar con PHPUnit, el poder testear las funciones o métodos de nuestro sistema de una manera sencilla, es muy bueno 😄


Reto completado.

Rubén Arturo Calderón García

Rubén Arturo Calderón García

hace 2 años

Sólo me queda la duda frente a como incluir el control de espacios en las contraseñas creadas \S mediante expresiones regulares.
Validate.php

<?php

  namespace App;

  class Validate
  {
    public static function email($value)
  {
      return (bool) filter_var($value, FILTER_VALIDATE_EMAIL);
  }

  public static function url($value)
{
    return (bool) filter_var($value, FILTER_VALIDATE_URL);
}

  public static function password($value)
{
  return (bool) preg_match('/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@#$!%&*?-_])[A-Za-z\[email protected]#$!%&*?-_]{8,16}$/', $value);
}
  }

ValidateTest.php

<?php

  use PHPUnit\Framework\TestCase;
  use App\Validate;

  class ValidateTest extends TestCase
  {
    public function test_email()
    {
      $email = Validate::email('[email protected]');
      $this->assertTrue($email);

      $email = Validate::email('[email protected]@hotmail,com,');
      $this->assertFalse($email);
    }

    public function test_url()
    {
      $url = Validate::url('https://platzi.com');
      $this->assertTrue($url);

      $url = Validate::url('https://platzi.com,com');
      $this->assertFalse($url);
    }

    public function test_password()
    {
      $password = Validate::password('@Crturo123');
      $this->assertTrue($password);

      $password = Validate::password('@Irtur_**');
      $this->assertFalse($password);
    }
  }
Samir Omar Murcia Vidal

Samir Omar Murcia Vidal

hace 2 años

Validar:

<class Validate
{
    public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/',$value);
    }
}>

Testear:

<class ValidateTest extends TestCase
{
    public function test_password()
    {
        $pass = Validate::password('123456');
        $this->assertTrue($password);
    }
}>
Ricardo Andres Zambrano Cuaicuan

Ricardo Andres Zambrano Cuaicuan

hace 2 años

Interesantes funciones