Programar con laravel 8

Vamos a explicar en el siguiente tutorial los pasos para empezar a programar con laravel 8 explicando arquitectura, comandos de consolA, el uso del ORM ELOQUENT y el motor de plantillas blade entre otras muchas cosas.

Laravel es muy similar a frameworks como Symfony o Zend teniendo partes en común siguiendo la lógica correspondiente del modelo vista controlador sus correspondientes ORM y motores de plantillas para cada framework en el caso de laravel el motor de plantillas es blade y ORM es Eloquent.

La curva de aprendizaje en Symfony es más grande por lo que casi se puede decir que si controlas bien este framework, Laravel te resulta mucho más sencillo. La documentación de laravel como se puede ver aquí es mucho más sencilla,llevadera e intutitiva que la de syfmony que es más complicada.
Una de las principales diferencias de laravel sobre symfony es tener una menor necesidad de tener que usar la consola en primera instancia para ir haciendo todo ya que usando cualquier controlador o modelo hecho anteriormente puedes seguir programando renombrando clases metodos modelos controladores etc...

El controlador se centra de primeras en estar preparado para mostrar vistas, mientras que el modelo se centra más en las tareas que tiene que hacer con el ORM de Laravel Eloquent y en crear métodos para que formen parte del modelo

Por otro lador para proyectos más grandes la consola de symfony aligera mucho la faena de ir haciendo la arquitectura en cuanto controladores,modelos,repositorios,formularios,plantillas y las relaciones entre ellos teniéndote que fijar principalmente en que se llamen bien en los archivos de configuración correspondientes.

Para poder tener preparado nuestro entorno de trabajo tenemos que tener habilitados nuestros servidores de desarrollo composer y la consola bien preparada para poder realizar las tareas.
Este punto ya está explicado en el artículo que se habla sobre symfony5 en los apartados de los puntos número 1 al número 3.
-1 Instalación de composer,
-2 Instalar un servidor web
-3 Creamos el correspondiente virtual host y su dominio local
En el siguiente enlace se puede ver los pasos detallados para implementar la parte de desarrollo.

Para ir haciendo funcionar el framework con funcionalidades básicas primeramente hay que descargarlo siguiendo los pasos que nos indica la documentación de laravel y luego poco a poco ir configurando la base de datos y las rutas básicas que nos lleven a mostrar las plantillas de laravel.

Para descargar el framework debemos de estar en la carpeta raíz de nuestra publicación y mediante la consola de composer tal como se nos indica en la documentación debemos escribir lo siguiente.
composer create-project laravel/laravel example-app

El example-app php se puede renombrar con el nombre que le demos a nuestra carpeta si todo va bien en la consola aparecerá como se va descargando el framework. El siguiente paso para poder trabajar correctamente sería hacernos un virtual host en nuestro servidor como se indica en el tutorial de symfony ya que la visualización de la vistas se realizan a través de la carpeta public, al subir esto a producción hay que tener esto cuenta para que cargue la carpeta public y poder ver correctamente la web.

Configuramos la base de datos que está en database o en el archivo env escogiendo la base de datos mysql. En el env está en la raiz mientras que el database se encuentra en config/database.php

Configuramos la base de datos que está en database o en el archivo env escogiendo la base de datos mysql. En el env está en la raiz mientras que el database se encuentra en config/database.php

En el config/database.php se encuentra las distintas conexiones para poder conectar a base de datos tales como mysql,sqllite,postgre entre otras por ejemplo para el caso de mysql el código sería algo similar a esto.

'mysql' => [
            'driver' => 'mysql',
            'url' => env('DATABASE_URL'),
            'host' => env('DB_HOST', '127.0.0.1'),
            'port' => env('DB_PORT', '3306'),
            'database' => env('DB_DATABASE', 'database'),
            'username' => env('DB_USERNAME', 'username'),
            'password' => env('DB_PASSWORD', 'password'),
            'unix_socket' => env('DB_SOCKET', ''),
            'charset' => 'utf8mb4',
            'collation' => 'utf8mb4_unicode_ci',
            'prefix' => '',
            'prefix_indexes' => true,
            'strict' => true,
            'engine' => null,
            'options' => extension_loaded('pdo_mysql') ? array_filter([
                PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
            ]) : [],
        ],

Mientras que en el .env de producción habría algo similar a lo siguiente para la conexión mysql

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=database
DB_USERNAME=username
DB_PASSWORD=password

En este punto mediante la fotografía podemos ver como la consola de composer con laravel nos crea los modelos y los controladores de una manera limpia y sencilla sin crearnos la estructura de plantillas como pasaba con twig y symfony.

En este punto laravel nos deja tanto como para el controlador como para el modelo recién creado un código la mar de limpio.

Controlador

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class InicioController extends Controller
{
    //
}

Modelo

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class InicioModel extends Model
{
    use HasFactory;
}

La creación de las rutas se hace desde routes/web.php y el código para implementarlo sería algo similar a esto. Mediante el método get llamariamos a la correspondiente vista inicio que se encontraría en resources\views\inicio.blade.php pasándole por la url el parametro ruta.

Route::get('/ruta', function () {
    return view('inicio');
});

En este caso con otra ruta fija llamamos al controlador InicioController y en su funcion Metodouno deberiamos de mostrar el correspondiente contenido de la vista.

En la carpeta app\Http\Controllers con su correspondiente namespace namespace App\Http\Controllers tendriamos nuestro controlador InicioController.

Llamada al controlador y su función

Route::get('/ruta2', 'InicioController@Metodouno');

El sencillo código de la clase con su método para visualizar el template sería algo como esto.

namespace App\Http\Controllers;

class InicioController extends Controller
{
    public $valor;

    public function Metodouno()
    { 
        $this->valor="1";
        return view('vista',compact($this->valor));
    }
      
}

Al haber llamado desde routes\web.php al controlador y al método este llama a la vista que se encuentra en resources\views\vista.blade.php en el caso de haber herencia de plantilla blae que estén separadas por carpetas se en la zona del return se debería poner algo parecido a lo siguiente basado en el ejemplo anterior.

return view('carpeta.vista',compact($this->valor));

En resources\views\carpeta\vista.blade.php es donde estaría en este caso la vista que se va a devolver.

Otro tipo de rutas sería el mismo caso que el anterior pero pasando el valor al método del controlador.

Route::get('/vercategorias/{valor}','InicioController@Metodouno');

public function Metodouno($valor)
    { return view('vista',compact($valor));
    }

En estos dos ejemplos se les pasa la correspondientes variables a la vista mediante la funcion compact y así en la plantilla mediante blade podemos ver el correspodiente contenido.

Un punto interesante a la mar que sencillo es comentar el tema de las páginas de error 404 hay que acceder para configuralo correctamente app\Exceptions\Handler.php.
En la zona donde sale ese código hay que redigirlo a una vista personalizada que crearemos en resources\views para que quede más claro es recomendable ponerle como nombre 404 y personalizala como consideremos oportuno

 public function render($request, Throwable $exception)
    { 
      
      if ($this->isHttpException($exception)):
      $code=$exception->getStatusCode();
      endif;

      //print_r($code);echo "
";
       
       if($code=='404'):
       return response()->view('404');
       else:
       return parent::render($request, $exception);
       endif;
        
        
    }

Laravel nos ofrece una lista de comandos que podemos activar para realizar nuestras tareas para visualizar lo que podemos obtener con cada uno de los comandos debemos ejecutar php artistan list y nos saldrá por pantalla algo parecido a lo que se puede visualizar por la imagen.

PLANTILLAS BLADE

Las plantillas usa el motor blade cuya sintaxis es muy parecida a la de php sobre todo para tareas de bucles for e if condicionales usando la lógica que usaba twig de bloques y herencias. Lo recomendable es hacer en una carpeta la plantilla padre con sus divisiones con bloques y luego en la plantilla hija que hereda simplemente que pinte los datos correspondientes.

En este caso mostramos lo que sería una estructura básica de la plantilla padre dentro de resources\views\layouts esta última carpeta layouts la creamos nosotros y va debajo de views.

En primer lugar vamos declarando los bloques correspondientes en la plantilla padre usando para ello la declaración yield en este caso usando y declarando @yields('zonaestilos') y en la plantilla hija que es la que hereda de la padre en la ruta src\views tendremos un arcnivo que llamaremos inicio.blade.php

En la plantilla hija lo primeros que podremos es la herencia que recibe y que pinte el bloque correspondiente que le corresponde.

Se extiende lo que hay en src\resources\layouts

@extends('layouts.inicio')

Pinta el bloque zona de estilos

 @section('zonaestilos')
 @stop

Esto se tendría que hacer para cada uno de los bloques en cada uno de los archivo blade.php en el archivo se puede osberva que existe un include poniendo el nombre del archivo hace lo mismo que un include normal de php por ejemplo.
@include(menu)->Metería menu.blade.php a su misma altura
@include(menu.menu)->Metería el template Menu.blade.php de la carepta menu

El código correspondiente la para plantilla hija que herea de la padre sería la siguiente.

Como se ha comentado anteriormente blade permite es muy parecido a php en cuanto a bucles y formatos condicionales permitiendo una gran facilidad para implementarlo a la hora de recorrer vectores por ejemplo.

Para obtener más información sobre el motor de plantillas y poderlo implementar directamente dejo el enlace aquí para que cualquiera se pueda documentar.

Consultas SQL

Para poder implentar nuestras consulstas sql nativasdebemos de implementar en nuestras clases el siguiente namespace. use Illuminate\Support\Facades\DB;
Y según el tipo de consulta que sea select insert update delete u otro tipos de consultas

Select
$results = DB::select('select * from tabla');
Insert
DB::insert('insert into tabla (id, campo) values ('1', 'campo1')');
Update
DB::update('update tabla set id = 1 where campo = 'campo'');
Delete DB::delete('delete from tabla where campo='campo'');
Otras Consultas DB::statement('drop table tabla;');

Otra manera de hacer las consultas es hacerlas con el query builder de laravel que nos ofrece ejemplos muy sencillos para poder sacar los datos correspondientes indicandole la tabla correspondiente y con los namespaces que se indican. Se pueden ver los ejemplos en el siguiente enlace. de manera completa

Hay más cosas para ver con laravel como por ejemplo en el envío de emails o las migraciones pero con el contenido del tutorial ya se tiene lo suficiente para empezar a trabajar. Por lo tanto en este punto recomiendo encarecidammente usar la consola de comandos de laravel consultándola y probándla mediante el siguiente comando php artisan list y consultandp la documentación oficial para laravel 8 que puede ver aquí