Post Top Ad

Your Ad Spot

domingo, 19 de abril de 2020

Laravel Eloquent

En este tema, aprenderemos sobre el modelo elocuente que permite la interacción con una base de datos. Cada tabla de base de datos tiene su modelo correspondiente que proporciona la interacción con una base de datos. El modelo le permite consultar los datos en sus tablas.
Los modelos se crean en el directorio de la aplicación . También puede colocar el modelo en cualquier lugar, que puede cargarse automáticamente de acuerdo con el archivo composer.json .
Podemos usar el siguiente comando para crear el modelo:
marca artesanal php: modelo Post
También podemos generar el modelo utilizando la migración de la base de datos:
marca artesanal php: modelo Post -m
o
marca artesanal php: modelo post-inmigración

Pasos para crear el modelo.

  • Cuando ingresamos el comando anterior en una ventana de Git bash:
Laravel Eloquent
La ventana anterior muestra que el modelo con el nombre ' Publicar ' se ha creado correctamente.
  • El modelo (Publicar) se crea en el directorio de la aplicación .
Laravel Eloquent

Estructura del modelo

La estructura de la clase de modelo que creamos arriba se muestra a continuación:
  1. <? php  
  2.   
  3. aplicación de espacio de nombres;  
  4.   
  5. use  Illuminate \ Database \ Eloquent \ Model;  
  6.   
  7. clase  Post  extiende el  modelo  
  8. {  
  9.     //  
  10. }  
El código anterior muestra que la clase Post extiende Illuminate \ Database \ Eloquent \ Model .

Nombres de tablas

En laravel elocuente, no necesitamos especificar el nombre de la tabla que se utilizará para el modelo Post. El nombre plural de la clase se considerará como el nombre de la tabla a menos que especifiquemos el nombre de la tabla explícitamente. Por ejemplo, en el código anterior, el nombre de la clase es Post que funciona en las publicaciones de la tabla. También puede especificar la tabla personalizada utilizando el atributo $ table de la clase de modelo que se muestra en el siguiente código:
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4.   
  5. clase  Post  extiende el  modelo  
  6. {  
  7.     / ** 
  8.      * La tabla asociada con el modelo. 
  9.      * * 
  10.      * @var cadena 
  11.      * /  
  12.     protegido $ table  =? posts ';   
  13. }  
En el código anterior, el atributo $ table especifica que la clase Post está usando la tabla posts.

Claves primarias

El modelo elocuente considera que cada tabla tiene una clave primaria llamada ' id '. Podemos anular esta convención proporcionando un nombre diferente al atributo $ primarykey .
  1. <? php  
  2.   
  3. aplicación de espacio de nombres;  
  4.   
  5. use  Illuminate \ Database \ Eloquent \ Model;  
  6.   
  7. clase  Vuelo se  extiende  Modelo  
  8. {  
  9.     / ** 
  10.      * La clave principal asociada con la tabla. 
  11.      * * 
  12.      * @var cadena 
  13.      * /  
  14.     protegido $ primaryKey  =  'post_id' ;   
  15. }  
Por defecto, en elocuente, la clave primaria es un valor entero auto-incrementado. Si queremos proporcionar el valor no incremental a la clave primaria, entonces tenemos que establecer el atributo incremental $ 'falso'.
public $ incrementing = false;
Si queremos proporcionar el valor no entero a la clave primaria, entonces tenemos que proporcionar un valor diferente al atributo $ keyType .
protegido $ keyType = 'string';
En lo anterior, estamos asignando el tipo de cadena a la clave primaria.

Lectura de datos

Ahora, veremos cómo recuperar los datos de la base de datos. Comprendamos a través de un ejemplo.
  • Primero, necesitamos agregar los dos atributos en una clase de modelo.
Post.php
  1. aplicación de espacio de nombres;  
  2. use  Illuminate \ Database \ Eloquent \ Model;  
  3. clase  Post  extiende el  modelo  
  4. {  
  5.     //  
  6. protected $ table 'publicaciones' ;   
  7. protegido $ primaryKey 'id' ;   
  8. }  
  • Agregamos la ruta que se utiliza para recuperar los datos de la base de datos.
web.php
  1. <? php  
  2. use  App \ Post;  
  3. Ruta :: get ( '/ read' function () {  
  4. $ posts = Post :: all ();  
  5. foreach $ publicaciones como $ publicaciones )    
  6. {  
  7.   echo $ post -> cuerpo;   
  8.   echo  ? <br>?  
  9. }  
  10. });  
En el código anterior, usamos el método all () que recupera todos los registros de la base de datos, y luego aplicamos el bucle foreach para recuperar el nombre del cuerpo de todas las filas disponibles en la base de datos, que se muestra a continuación.
En la siguiente captura de pantalla, podemos ver que hay dos registros disponibles en la tabla de publicaciones .
Laravel Eloquent
Salida
Cuando ejecutamos la url, localhost / firstproject / public / read , el resultado sería:
Laravel Eloquent
Si queremos recuperar el registro particular de la base de datos, entonces usamos el método find () .
  1. Ruta :: get ( '/ find' function () {  
  2. $ posts = Post :: find (2);  
  3. devolver $ posts -> título;   
  4. });  
Salida
Ejecute la url, localhost / firstproject / public / find para ver la salida del código anterior.
Laravel Eloquent

Leer datos con restricciones

  • Para recuperar una sola fila, utilizamos el método first () como se muestra a continuación:
  1. Ruta :: get ( '/ find' function () {  
  2. $ posts = Post :: where ( 'id' , 2) -> first ();  
  3. devolver $ publicaciones ;   
  4. });  
Salida
Laravel Eloquent
  • Si no necesitamos recuperar la fila completa, entonces podemos usar el método value () para recuperar el valor de una columna directamente.
  1. Ruta :: get ( '/ find' function () {  
  2. $ posts = Post :: where ( 'id' , 1) -> value ( 'title' );  
  3. devolver $ publicaciones ;   
  4. });  
Salida
Laravel Eloquent

Insertar datos

Ahora, veremos cómo insertar los datos en una base de datos. Veamos un ejemplo a continuación:
  1. Ruta :: get ( '/ insert' function () {  
  2. $ post nueva  publicación;  
  3. $ post -> title = 'Nishka' ;  
  4. $ post -> body = 'Analista de control de calidad' ;  
  5. $ post -> save ();  
  6. });  
Salida
Ejecute la url, localhost / firstproject / public / insert en un navegador web. Después de ejecutar la url, abra phpmyadmin.
Laravel Eloquent
El resultado anterior muestra que los datos se han insertado correctamente.

Actualización de datos con el método save ()

También podemos actualizar los registros utilizando el método save (). Comprendamos a través de un ejemplo.
  1. Ruta :: get ( '/ basicupdate' function () {  
  2. $ post = Post :: find (2);  
  3. $ post -> title = 'Haseena' ;  
  4. $ post -> body = 'Diseñador gráfico' ;  
  5. $ post -> save ();  
  6. });  
Salida
Laravel Eloquent
La pantalla anterior muestra la tabla de la base de datos, que es anterior a la ejecución del código anterior.
Cuando ejecutamos el código anterior, los datos se actualizan como se muestra en la pantalla a continuación.
Laravel Eloquent

Asignación masiva

Para proporcionar la asignación masiva, necesitamos usar el método create () y también proporciona la propiedad $ fillable en una clase de modelo.
Comprendamos a través de un ejemplo.
  • Primero, cree la ruta, y agregamos el método create () en la función de cierre. El método create () básicamente está agregando un nuevo registro, y los valores se proporcionan a través de su parámetro. Primero, cree la ruta, y agregamos el método create () en la función de cierre. El método create () básicamente está agregando un nuevo registro, y los valores se proporcionan a través de su parámetro.
  1. Ruta :: get ( '/ create' function () {  
  2. Post :: create ([ 'title' => 'Harshita' 'body' => 'Technical Content Writer' ]);  
  3. });  
  • Para proporcionar la asignación en masa, necesitamos agregar el atributo $ fillable en una clase de modelo como se muestra en el código a continuación.
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4. clase  Post  extiende el  modelo  
  5. {  
  6.     //  
  7. protected $ table 'publicaciones' ;   
  8. protegido $ primaryKey 'id' ;   
  9. protegido $ rellenable =   
  10. [  
  11. 'título' ,  
  12. 'cuerpo'  
  13. ];  
  14. }  
Salida
Ejecute la url, localhost / firstproject / public / create para ejecutar el código anterior.
Laravel Eloquent
Ahora, mira la base de datos.
Laravel Eloquent
El área resaltada arriba muestra que el nuevo registro se ha creado con éxito.

Actualización de datos con Eloquent

Ahora, veremos cómo actualizar los datos usando elocuente. Comprendamos a través de un ejemplo.
  • Primero, crea la ruta.
  1. Ruta :: get ( '/ update' function () {  
  2. Post :: where ( 'id' , 1) -> update ([ 'title' => 'Charu' 'body' => 'Technical Content Writer' ]);  
  3. });  
En el código anterior, usamos el método update () de la clase de modelo. Estamos actualizando el registro que tiene una identificación igual a 1.
Salida
Laravel Eloquent
Laravel Eloquent

Eliminar datos

Ahora, veremos cómo eliminar los datos usando Eloquent. Implementamos directamente el método delete () disponible en la clase de modelo elocuente.
Hay diferentes formas de eliminar los datos.
  • La primera forma es usar el método find () y delete ().
  1. Ruta :: get ( '/ delete' function () {  
  2. $ post = Post :: find (1);  
  3. $ post -> eliminar ();  
  4. });  
Salida
Laravel Eloquent
Laravel Eloquent
  • La segunda forma es usar el método destroy () .
  1. Ruta :: get ( '/ destroy' function () {  
  2. Publicar :: destruir (2);  
  3. });  
Salida
Laravel Eloquent
Laravel Eloquent
Si queremos destruir más de una fila,
  1. Ruta :: get ( '/ destroy' function () {  
  2. Publicar :: destruir ([3,4]);  
  3. });  
El código anterior está destruyendo los registros que tienen id, 3 y 4.
Salida
Laravel Eloquent
Laravel Eloquent
  • La tercera forma es usar la consulta.
  1. Ruta :: get ( '/ delete1' function () {  
  2. Post :: where ( 'id' , 5) -> delete ();  
  3. });  
Salida
Laravel Eloquent
Laravel Eloquent

Eliminación suave / Papelera

También hay otra forma de eliminar los registros es la eliminación suave. Cuando los modelos se eliminan temporalmente, significa que los registros no se eliminan realmente de la base de datos. En la eliminación suave, los registros no se eliminan permanentemente; se almacenan en el espacio de basura.
Comprendamos a través de un ejemplo de cómo se realiza la eliminación suave.
  • Primero, necesitamos establecer el atributo deleted_at en la clase de modelo.
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4. use  Illuminate \ Database \ Eloquent \ SoftDeletes;  
  5. clase  Post  extiende el  modelo  
  6. {  
  7.  usar  SoftDeletes;  
  8. protected $ table 'publicaciones' ;   
  9. protegido $ primaryKey 'id' ;   
  10. Protegido $ date = [ 'deleted_at' ];   
  11. }  
  • Ahora, realice la migración para agregar una columna deleted_at en la tabla de publicaciones.
Laravel Eloquent
  • Como hemos creado la migración con un nombre add_column_deleted_at , su estructura se da a continuación:
  1. <? php  
  2.   
  3. use  Illuminate \ Support \ Facades \ Schema;  
  4. use  Illuminate \ Database \ Schema \ Blueprint;  
  5. use  Illuminate \ Database \ Migrations \ Migration;  
  6.   
  7. La clase  AddColumnDeletedAt  extiende la  migración  
  8. {  
  9.     / ** 
  10.      * Ejecuta las migraciones. 
  11.      * * 
  12.      * @return void 
  13.      * /  
  14.     función pública  up ()   
  15.     {  
  16.         Schema :: table ( 'posts' ,  function  (Blueprint  $ table ) {  
  17.             $ tabla -> softDeletes ();  
  18.         });  
  19.     }  
  20.   
  21.     / ** 
  22.      * Revertir las migraciones. 
  23.      * * 
  24.      * @return void 
  25.      * /  
  26.     función pública  abajo ()   
  27.     {  
  28.         Schema :: table ( 'posts' ,  function  (Blueprint  $ table ) {  
  29.             $ tabla -> dropColumn ( 'deleted_at' );  
  30.         });  
  31.     }  
  32. }  
Laravel contiene el método auxiliar conocido como softDeletes () , que hemos utilizado en el código anterior. El método softDeletes () se usa para crear la columna.
  • Ahora, ejecute el comando php artisan migrate .
Laravel Eloquent
  • Al final, agregue la ruta en el archivo web.php para ejecutar las eliminaciones suaves.
  1. Ruta :: get ( '/ softdelete' function () {  
  2. Post :: find (1) -> delete ();  
  3. });  
En el código anterior, estamos eliminando el registro que tiene la identificación '1'.
Salida
Laravel Eloquent
Laravel Eloquent
En la pantalla anterior, la columna deleted_at muestra la hora a la que este registro se ha eliminado temporalmente. Si esta columna contiene el valor nulo, significa que este registro no se elimina por software.

Recuperando datos borrados / basura

Para recuperar los datos eliminados, utilizamos el método withTrashed () . Vamos a entender esto a través de un ejemplo.
  1. Ruta :: get ( '/ readsofdelete' function () {  
  2. $ post = Post :: withTrashed () -> where ( 'id' , 1) -> get ();  
  3. return $ post ;   
  4. });  
En lo anterior, estamos recuperando el registro que está en la papelera o que se ha eliminado temporalmente.
Salida
Laravel Eloquent

Restaurar datos eliminados / descartados

En el tema anterior, vemos cómo recuperar los datos del modelo eliminado temporalmente. Ahora, veremos cómo restaurar los datos del espacio de basura al lugar original. Vamos a entender esto a través de un ejemplo.
  1. Ruta :: get ( '/ restore' function () {  
  2. Post :: withTrashed () -> where ( 'id' , 1) -> restore ();  
  3. });  
En el código anterior, estamos restaurando los datos que están en la papelera utilizando la función restore () .
Salida
Laravel Eloquent
Laravel Eloquent
La pantalla anterior muestra que el valor de la columna deleted_at es NULL, lo que significa que el registro se restaura en una base de datos.

Eliminar registros permanentemente

A veces necesitamos eliminar los datos de forma permanente. Para eliminar el modelo eliminado de forma permanente, utilizamos el método forceDelete () . Vamos a entender esto a través de un ejemplo.
  1. Ruta :: get ( '/ forcedelete' function () {  
  2. Post :: onlyTrashed () -> forceDelete ();  
  3. });  
En el código anterior, estamos eliminando los datos que están en la papelera.
Antes de la ejecución del código anterior, el registro de la papelera tiene una identificación igual a 1 que se muestra en la siguiente captura de pantalla.
Laravel Eloquent
Cuando ejecutamos el código anterior, el registro de la papelera se eliminará y la tabla desearía, como se muestra a continuación:
Laravel Eloquent

Tema siguiente Relación de Laravel

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas