Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Resumen final

16/16
Recursos

Aportes 45

Preguntas 2

Ordenar por:

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

Gracias por llegar hasta aquí, ahora ve por el examen 😃

Este curso sí está mucho mejor, a la altura de la academia.

🧠 Entender la flexibilidad y potencia de PHP, me permitió comprender la importancia de las buenas prácticas del lenguaje.
https://phpbestpractices.org/

Lo que me encanta de PHP es que es super flexible como lenguaje, me gustó el curso, voy por el examen!

Muy bueno el curso, muy mal hecho el examen.

Vengo de java y cada vez me sorprende mas la simpleza de php. Sin embargo creo que no hay que abusar de tanta flexibilidad que brinda el lenguaje, porque podríamos caer en malas practicas de programación.
Excelente curso profe Italo, muchas gracias.

excelente curso, ojala el profesor Italo haga mas cursos, uno en donde podamos aplicar de manera mas practica lo que nos ha enseñado

Pd: dejo mis apunte de todo el curso

Comillas

  • Comillas simples

    • Puedo escribir texto de una o varias lineas
    • Los caracteres que puedo escapar son ’ y \
    • Si quiero utilizar el valor de una variable, como ejemplo $variable, lo imprime exactamente igual, no toma el valor que esta dentro de la variable
    • Para utilizar el valor de una variable es necesario utilizar la concatenacion
  • Comillas dobles

    • Aqui si podemos tomar el valor de una variable
  • Si la estructura a imprimir es compleja

Para estos casos utilizamos las llaves para escapar, asi le indicamos a php que esa es una estructura compleja y que la analice detenidamente

  • Necesitamos utilizar llaves tanto al inicio como al final de la impresion
  $courses = [
      'backend' => [
          'PHP',
          'Laravel'
      ]
  ]

  echo "{$courses['backend'][0]}"
  • Si queremos escribir algo contenido en una clase

    Utilizamos una especie de flechita

      class User{
          public $name = "Matias";
      }
    
      //creamos la instancia
      user = New User;
    
      //imprimimos
      echo "user->name"
    

    Utilizando variables variables

        $teacher = 'italo';
        $italo = 'Profesor de PHP';
    
        echo "$teacher es ${$teacher}";
    

    Esto tambien podemos hacerlo con funciones

        function getTeacher(){
            return 'teacher';
        }
        echo "${getTeacher}"
    

Extraccion de datos

  • Una string es un objeto iterable

podemos indicar el indice que queremos seleccionar entre llaves o entre corchetes, es decir:

  • data[0];

  • data{0};

  • funcion substr

significa substraer string. La sintaxis es la siguiente

    substr($valor, 0, 20);

Asi indicamos, de donde tiene que substraer, desde donde tiene que empezar y hasta que indice tiene que llegar

  • function explode

pasar de texto a un array separando los elementos mediante un valor. Por ejemplo

    $data = 'javascript, php, laravel';
    $tags = explode(', ', $data);

    //utilizamos var_dump() para imprimir un array
    echo "<pre>";
    var_dump($tags);
  • Etiqueta <pre>

Es una etiqueta propia de PHP, lo que nos permite es extructurar mejor la informacion a imprimir

  • Funcion implode

Es el contrario de la funcion explode, lo que hace es pasar de un array a un string. La sintaxis es la misma.

  • Funcion trim

Lo que hace es eliminar los espacios restantes tanto al final como al inicio.
Tiene otras dos variantes:

  • ltrim($string)
  • rtrim($string)

Formatear datos

Alterar texto

  • strtoupper(str): texto a mayusculas
  • strtolower(str): texto a minusculas
  • ucfirst(str): upper case primera letra
  • lcfirst(str): lower case primera letra

Reemplazar

  • str_replace(‘reemplazar’, ‘por’, en $variable)

Modificar

  • str_pad():
    Por ejemplo, para imprimir el numero de una factura, necesitamos que tenga 8 digitos.
    Asi que queremos imprimir el numero de factura actual y el espacio restante rellenarlo con #
    $code = 39;
    echo str_pad($code, 8, '#');

    //salida: 39######

Si agregamos el parametro STR_PAD_BOTH lo que hara sera centrar el numero actual de nuestra factura y rellenar con # a los lados

    $code = 39;
    echo str_pad($code, 8, '#', STR_PAD_BOTH);

    //salida: ###39###

Tambien podemos utilizar STR_PAD_LEFT y STR_PAD_LEFT

  • strip_tags():
    Lo que hace es, si tenemos etiquetas HTML dentro de una string en PHP, nos devuelve el texto sin esas etiquetas
    $text = '<h1>Hola mundo</h1>';
    echo strip_tags($text);

Elementos Monobyte y Multibyte

Cuando trabajamos caracteres especiales, como por ejemplo la ñ o la ó, no son interpretados correctamente en las funciones strtoupper entre otras, es decir que no convierte el caracter a mayuscula

Cuando nos topamos con un elemento como este decimos que estamos trabajando con un elemento multibyte

Solucionarlo es muy sencillo

    $text = 'Hola ña ñeca';

    echo strtoupper($text);
    //salida: HOLA ñA ñECA

    echo mb_strtoupper($text);
    //salida: HOLA ÑA ÑECA

asi le indicamos a PHP que estamos trabajando con un elemento Multibyte

Expresiones regulares

Simbolos

  • /: CONTENEDOR
  • ^: INICIO
  • $: FINAL
  • -: RANGO
  • []: PATRÓN
  • {}: CONDICIÓN
    PHP tiene una funcion para utilizar expresiones regulares, la cual es preg_match
    preg_match("/^[0-9]{6,9}$/");

Iniciando nuestro proyecto

Utilizaremos composer y phpunit

Lo primero que hacemos es requerir phpunit para el desarrollo

composer require --dev phpunit/phpunit

Luego de eso, modificamos el archivo composer.json y le agregamos un nombre, despcripcion y configuramos el autoload

{
    "name": "matias-ed/validate",
    "description": "proyecto de validacion",
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "require-dev": {
        "phpunit/phpunit": "^9.5"
    }
}

Creamos el archivo phpunit.xml donde especificamos en que carpeta se encuentran nuestros tests

<?xml version="1.0" encoding="UTF-8"?>
<phpunit bootstrap="vendor/autoload.php" colors="true">
    <testsuite name="Test directory">
        <directory>tests</directory> 
    </testsuite>
</phpunit>

Creamos la carpeta tests y dentro de ella creamos el archivo ValidateTest.php
obs: Es buena practica que los archivos de testing terminen en Test

    <?php

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

    class ValidateTest extends TestCase
    //TestCase es una clase de PHPUnit
    {
        public function test_email()
        {
            $email = Validate::email("[email protected]");
            //aqui llamamos al metodo email de la clase Validate que aun no hemos creado

            $this->assertTrue($email);
            //Es un metodo de TestCase
        }
    }

Por ultimo creamos nuestra carpeta src/ y adentro creamos nuestra clase Validate

    namespace App;

    class Validate
    {
        public static function email($value)
        {
            return (bool) filter_var($value, FILTER_VALIDATE_EMAIL);
        }
    }
    //filter_var es una funcion propia de php que me permite filtrar a mis variables
    //FILTER_VALIDATE_EMAIL es una constante propia de PHP

Revision del proyecto

  • Los archivos que utilizamos para testing siempre deben acabar con Test. Por ejemplo Validate_Test o ValidateTest
  • Los metodos dentro de nuestras clases de testing tambien deben empezar por test. Por ejemplo test_email o testEmail

Funciones

  • Argumentos
    Son los valores que colocamos dentro de los parentesis
  • Referencia
    Que observa directamente el comportamiento de otro elemento
    $course = 'PHP';
    function path($course)
    {
        $course = 'Laravel';
        echo $course;
    }

    path($course);
    echo $course;

Esta function solo modifica el valor internamente en la funcion, quiere decir que fuera de la function $course sigue teniendo el valor ‘PHP’

Si queremos que tambien se modifique el valor global agregamos un &

    $course = 'PHP';
    function path(&$course)
    {
        $course = 'Laravel';
        echo $course;
    }

    path($course);
    echo $course;
  • Parametro o argumento predeterminado
    Es el valor por defecto que tiene un argumento

  • Return
    Lo que hace es devolver un resultado

  • Exit()
    Es una funcion que detiene el sistema

Funciones anonimas

Una funcion anonima se usa en una variable que requiere logica
Nos referimos a ella a traves de una variable

    $greet = function($name){
    return "Hola $name";
    };
    $greet("Matias");
  • Closure
    Sirve para especificar que esperamos una funcion anonima como parametro

Arrays

  • Array simple

Son aquellos a los cuales no hemos definido ningun key

  • Array complejo

Son aquellos que ya cuentan con clave => valor

Formas de recorrer un array complejo

Utilizando foreach

    $courses = [
        'frontend' => 'JavaScript',
        'framework' => 'React',
        'backend' => 'PHP'
    ];

    foreach ($courses  as $key=>$value)
    {
        echo "$key: $value<br>";
    }

Utilizando array_walk

    $courses = [
        'frontend' => 'JavaScript',
        'framework' => 'React',
        'backend' => 'PHP'
    ];

    function upper($course)
    {
        echo strtoupper($course). "<br>";
    }

    array_walk($courses, 'upper');

Otras funciones para manipular arrays

  • array_key_exists(‘frontend’, $variable)
    pregunta si la clave ‘frontend’ existe
  • in_array(‘javascript’, $variable)
    pregunta si el elemento existe dentro del array
  • array_keys($variable)
    devuelve todas las claves del array
  • array_values($variable)
    devuelve todos los valores del array
  • sort($array)
    ordena los valores de manera ascendente
  • rsort($array)
    ordena los valores de manera descendente
  • ksort($array)
    ordena los valores de manera ascendente segun los keys
  • krsort($array)
    ordena los valores de manera descendente segun los keys
  • array_slice($array, index)
    devuelve los valores del array desde el indice indicado
  • array_chunk($array, size)
    divide el array indicado en varios arrays del tamaño indicado
  • array_shift($array)
    elimina el primer elemento del array
  • array_pop($array)
    elimina el ultimo elemento del urray
  • array_unshift($array, element)
    agregamos un elemento en el indice 0
  • array_push($array, element)
    agregamos un elemento en la ultima posicion del array
  • array_flip($array)
    hace un intercambio entre valores y llaves. El valor pasa a ser un key y el key pasa a ser el valor

Comparacion entre arrays

  • array_diff($array_1, $array_2)
    nos devuelve los elementos que estan en el $array_1 que no estan en el array_2
  • array_diff_assoc($array_1, $array_2)
    compara arrays complejos

Union de arrays

  • sumando las variables
    podemos simplemente hacer lo siguiente
    $array_1 + $array_2

sin embargo aqui se sobreescriben los indices. Si tenemos dos arrays con indice 0, el elemento que esta en el indice 0 del array 1 sobreescribe a el elemento del indice 0 del array 2. Tenemos dos formas de solucionar esto

  1. Agregando keys diferentes a cada elemento
  2. funcion array_merge(array_1, array_2)
    esto une los arrays, pero solo funciona cuando los indices numeros. Si indicamos claves a cada elemento, y algun de las claves se repite en los arrays, tambien se sobreescribira el valor. Esto podemos solucionarlo con:
  • array_merge_recursive:
    la solucion que nos da php es crear un array con la clave que se repite y ahi guarda los dos valores
  • array_combine(key_array, value_array)
    lo que hace es, tomar cada elemento del key_array como una clave, y va guardando un elemento del value_array como valor de esa clave.

Dejo por aquí el Repositorio en github por si lo necesitan :3

El curso lo he visto medianamente bien, pero la redacción de algunas preguntas del examen final de parecen de risa. Llevo varios años en Platzi y no me había pasado esto jamás. Cuando lo hagás (creo que) lo entenderás.

Genial el curso

Muy buen curso, me encanta como enseña Italo.

Aprendí bastante 😄

Muy buen curso. Excelente ritmo y explicaciones claras.

Excelente curso, me ha ayudado a entender desde cero (casi) poder lograr entender este curso.

Muchas gracias por tan excelente curso y tan buen profesor

Excelente Curso 👌

esta super bueno el curso!! y con estas clases puedo apreciar todo el potencial que tiene PHP, y entender que no es un mal lenguaje como muchos opinan, sino uno muy flexible donde depende de quién programa, crear buen código y dar solución a problemas!!

Muy buen curso!

excelente curso, muchas gracias ahora a seguir practicando para no olvidarlo.

A por ello

Gracias excelente curso!

Me gusto mucho el curso, aprendí mucho de PHP. Gracias Italo.

Buena explicacion Italo,muy buen curso.

Excelente Curso! Voy por otro examen! Gracias Italo!

Gracias excelente curso !

Excelente curso, estoy aprendiendo claramente los temas

Muchas gracias Italo , perfecta explicación.

El modulo de los arrays me ayudo mucho.

Buen curso, aun ando algo perdido en la parte de composer, pero espero se explique a detalle más adelante

La verdad es que tenía mucha inseguridad de empezar los cursos de php, creyendo que se me harían muy complicados, pero el profesor explica excelente. A por los demás cursos de PHP 😄

Muy buena explicación, ya termine el examen y php me esta sorprendiendo.

En lo personal el tema de los array siempre me ha costado entenderlo bien. Sin duda este curso me ayudo a tener una base más sólida. Excelente curso!

bastante interesante, muy buen maestro

Excelente curso y explicación del profesor
Gracias por compartir su conocimiento

Que buen curso, aprendí cosas que aún no sabía.

excelente. 5.0

Muy buen curso…

Con esta ojeada que vimos a las pruebas unitarias quede muy motivado para profundizar en el tema.
Gracias profesor!

Excelente curso Italo, muy concreta la enseñanza, creo que seguiremos por mas…

vine buscando cobre y encontré oro

Genial este curso, gracias Italomoralesf

Excelente e interesantes explicaciones sobre el manejo de datos en PHP

Excelente curso. Sigo aprendiendo teniendo conocimientos anteriores. Gracias!

A pesar de ser fundamentos básicos del lenguaje me han servido mucho los temas como un repaso general, sobre todo por la forma de explicar del profesor, ha sido muy fácil de entender los conceptos.