….centrado en crear soluciones que importen
Puedes hacer esto en la plantilla de tu aplicación, empleando el with en Blade, en modo dinámico, uniéndolo al nombre del modelo.
Post::whereSlug('slug')->get();
// en vez de esto
View::make('posts.index')->with('posts', $posts);
// podemos hacer esto
View::make('posts.index')->withPosts($posts);
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
Subir montañas hermana a los hombres……
Entender el concepto de clases es un elemento basico cuando programamos, ya que en si, las clases constituyen la base de la organización estructural del codigo de programacion moderno.
Las clases nos permiten crear objetos que podremos reusar o no, pero que facilitaran la escalabilidad y eficiencia del codigo.
¿Por que?
Porque la clase es como el molde de un zapatero.
Es la base para crear un objeto, lo cual permitira organizar el codigo de una manera muy como en el mundo que nos rodea.
Digamos sin ser muy profundos que un zapato de caballero, tiene cualquiera que sea el modelo, varias partes comunes: tacon, puntera, plantilla, etc.
Entonces el molde será la clase, cada modelo será un objeto de esa clase y cada caracteristica un atributo.
De la clase zapato pueden crearse diferentes objetos que seran usados de diferentes formas, venderse, exhibirse, trasladarse, y para eso necesitará relacionarse con otras clases, como tienda, caja, etc.
De estas relaciones es que hablaré, por la necesidad de su comprension para crear una mejor aplicación.
Las clases pueden relacionarse asociandose, dependiendo una de otra o mediante herencia.
Tomemos como ejemplo una base de camiones para transporte. La relación de asociación es aquella necesaria para que la estructura funcione.
Como la que hay entre un usuario_chofer y su camión, donde se relacionan en ambas direcciones, elusuario chofer posee un camión y ese camion pertenece a ese chofer.
Una relación parecida a esta pero de una sola dirección es la que se da entre la clase combustible y camión. Digamos que hay dos acciones que el camión realiza sobre el combustible en cada viaje: recibirlo y gastarlo por tanto es una relación unidireccional
Una expresion de esta relación seria algo asi
clase Camion {
variable viaje;
función constructor()
{
$viaje = new Combustible();
}
funcion publica recibir()
funcion publica gastar()
}
clase Combustible { }
Lo anterior intenta mostrar la estructura básica de una clase, no está escrito en ningún lenguaje específico aunque inspirado en php y python
Ahí vemos dos clases camión y combustible con una variable viajes que crea un nuevo objeto de combustible sobre el cual incidirá el objeto camión del que se trate, con dos métodos recibir y gastar.
Toda relación tiene multiplicidad doble, porque se ubica a cada lado de la relación y esta tiene un minimo y un maximo.
La mejor forma de explicarlo es entendiendo por ejemplo las relaciones entre las tablas de una base de datos del tipo relacional.
Los tipos son
1 indica que la multiplicidad a cada lado de la relación es de uno y solo uno
0..1 indica una multiplicidad de 0 o 1 y viene a ser el complemento de una relación de uno
* indica una relación de cero o varios ( presente en el lado extremo varios del tipo de relación de unos a varios
*..0 cero o varios
1..* uno o varios
La multiplicidad, define además que cuando la mínima es 0, la relación es opcional y si es mayor o igual que 1 se establece como una relación obligatoria.
Entonces nuestras tablas en una base de datos relacional tendrán una relación de:
uno a uno si a ambos lados de la relación existe un uno
de uno a muchos si a un lado hay un 1 y al otro *
de muchos a muchos si a cada lado hay un *
Y por supuesto sus inversos.
Y para analizar la obligatoriedad por ejemplo en una bd con dos tablas: viajes y camiones, podemos decir que un camión podrá tener o no viajes (opcional-> 0..*), pero un viaje pertenecerá si o si un camión (obligatoria->1..*)
Es el tipo de relación, que existe entre dos clases que se necesitan para que la estructura funcione, por ejemplo siguiendo en el área transporte:
no puede hacerse un viaje si no están al clases orden de viaje y camión.
Un modo de verlo es pensar en un objeto que solicita un recurso o un servicio y otro que lo brinda.
Son relaciones que surge cuando una subclase hereda los atributos de una superclase. Un ejemplo práctico es pensar en familias de animales, digamos que tenemos una clase llamada Paquidermos.
Esta superclase entre otros atributos tiene:
tipo, trompa(posee un método llamado añadirTrompa) y cola = corta
De ella heredaran diferentes subfamilias, elefantes, rinocerontes, hipopótamos, con características y comportamientos parecidos ( no sudan, piel gruesa, y grandes dimensiones).
Sin embargo, las subfamilias(subclases), pueden incorporar características nuevas comunes a solo algunas, ejemplo hipopótamos y rinocerontes necesitan refrescarse constantemente.
Podemos seguir creando subclases y derivando. Por ejemplo de la clase elefante, pueden heredar las subclases elefante africano y elefante asiático.
Mientras que del rinoceronte heredaran 5 subclases: el de java, el indio, el negro, el blanco y el de Sumatra
Y del hipopotamo heredaran: el hipopotamo común y el hipopotamo pigmeo.
Para estas subclases existirán atributos de con acceso de carácter privado, de carácter protegido y de carácter público.
Expliquémoslo a través del la subclase elefante:
Si en la superclase existe el atributo tipo, para la elefante será público ya que puede acceder a el, tanto elefante como elefante africano y elefante asiático.
El atributo cola, será privado, y no podrá acceder ninguna subclase, para todos la cola tiene un valor “corta”.
Y la variable trompa, es protegida ya que solo podrá acceder la propia clase Paquidermo y sus subclases mediante el método añadirTrompa.
Otra propiedad de trabajar con clases es el encapsulamiento
Es justo lo que hemos visto en la relaciones , o sea es el mecanismo que se emplea para organizar los datos y métodos de un objeto, limitando el acceso a ellos solo por el modo que se determine .
Por tanto al crear la clases y respetar estas relaciones estamos encapsulando, todo cuanto necesitamos en una entidad, o estructura, o dicho de otro modo en un objeto
Al encapsular podemos abstraer, o sea podemos al tener concentrados los componentes de un objeto, crear superclases que representan de la manera más abstracta posible los objetos que irán heredando de ellas.
Ser fácil entender entonces, que las formas de encapsular pueden ser :
Relacionado con la herencia tenemos que entender el poliformismo
No es más que capacidad que tienen los objetos de una clase para responder ante un mensaje en dependencia de los parámetros que utilicemos al invocarlos o llamarlos.
Creo que la forma más sencilla de mostrarlo es que llamemos desde cualquiera de las clases que derivan de Paquidermos al atributo trompa, podremos acceder a él mediante el mismo método añadirTrompa ().
En definitiva el uso de clases y su aprovechamiento permite controlar el comportamiento del usuario, evitando acciones indeseadas, además de que el medio mas efectivo para controlar y manejar la complejidad de las Clases , obligandolas a actuar como cajas negras, que dejan ver mediante una interfaz el comportamiento pero no los detalles internos.
Lo cual es una ventaja ya que ayuda al programador a separar la interfaz de una clase de su implementación.
De este modo es más fácil limitar el acceso a los datos y que solo se haga mediante las funciones que ponemos a su disposición, con las validaciones que consideremos necesarias.
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
….un sueño es casi todo y más que nada, más que todo al soñarlo, casi nada después……
Un error común al intentar instalar Laravel es Could not open input file: artisan:
Could not open input file: artisan
Para corregirlo correr composer install
Composer could not find a composer.json file in C:\xampp\htdocs\portfolioTo initialize a project, please create a composer.json file as described in the https://getcomposer.org/ "Getting Started" section
Esto sucede cuando has creado un proyecto y has descargado y extraido laravel desde el repositorio en GitHub, no utilizando el comando de Composer.
composer create-project laravel/laravel your-project-name
Y esto se debe a que las dependencias que Composer maneja no están instaladas, por lo tanto la carpeta vendor que contiene a Artisan no ha sido creada.
La solución a este problema es correr el comando composer install, en la carpeta raíz del proyecto, para ello lo que recomiendo es borrar la carpeta de nuestro proyecto y corriendo todo el proceso de nuevo.
Artisan incorpora Laravel por defecto, por tanto si php esta correctamente instalado lo único que necesitas es navegar hasta la carpeta raíz del proyecto, o sea la carpeta dentro de la cual hallaremos la carpeta App
cd c:\Program Files\xampp\htdocs\your-project-name
Corremos
composer global require "laravel/installer"
el cual actualizara composer a nivel de variables de entorno generalmente en
C:/Users/nombredeusuario/AppData/Roaming/Composer
Y luego creamos nuestro proyectos ubicados en el root del servidor local
En mi caso xampp
C:\xampp\htdocs>composer create-project laravel/laravel nombre_del_proyecto
Luego pasamos al proyecto creado e iniciamos, el serve de artisan, para comprobar que funciona.
También podemos comprobar la version de composer corriendo composer -v
C:\xampp\htdocs\ nombre_del_proyecto >php artisan serve
Una vez hecho esto el comando php artisan list por ejemplo debe correr perfectamente, porque PHP, estará llamando al archivo “artisan”, que se encuentra dentro de la carpeta del proyecto
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
… lo que realmente importa no es lo que te da la vida, sino lo que haces con ello……..
Desarrollar funciones en Python pueden ser necesario para hallar solucion a problemas que otras funciones existentes no nos resuelven.
La librería del lenguaje no deja de crecer, pero es común que si actuamos como investigadores, en mas de una ocasion, no encontremos lo que necesitamos para obtener la respuesta que buscamos.
En Python como en muchos otros lenguajes existen funciones y métodos.
Veamos a una función como trozo de código que controla o ejecuta un conjunto de instrucciones, y a la que podemos necesitar utilizar varias veces, esperando siempre el mismo comportamiento.
Los tipos de funciones en Python son tres:
Las que son predefinidas como print() o help().
Las que son definidas por el usuario, ya que este las crea
Las funciones anónimas, o funciones lambda, llamadas asi porque no se declaran bajo el standard def, que es el que usa python en el resto de los casos.
Antes de ir más allá, algo básico a la hora de escribir código en Python como en todo lenguaje de programación, son los comentarios, o la documentación que explique lo que estamos creando.
Añadir docstrings a la función, permite conocer su comportamiento esperado, ya que mediante su descripción documentamos todo aquello que consideramos importante, para entender que hace.
Los docstring se colocan justo después de la primera línea de la función, y se inicializan con tres comillas dobles, y se finaliza de igual modo.
def nada(): """ esta función no hara nada retornara un campo de tipo none """ return
Los métodos son pequeñas funciones, que forman parte de una clase, por tanto se accede a ellos instanciando esta o con un objeto, a diferencia de una función típica que puede ser llamada sin esa restricción.
Puede parecer confuso, pero la mejor forma de verlo es pensando que: todos los métodos son funciones pero no todas las funciones son métodos.
Por ejemplo una función puede ser:
def función_x(a,b,c): return a*b+c
Habiendo definido la función y lo que esperamos de ella, para llamarla solo debemos asignar valores a sus parámetros
función_x(2,3,5)
Comparemos como seria al crear una clase:
class Resultado(object): def solucion(self, a,b,c): self.contents = a*b+c return self.contents
Si ahora deseamos llamar al método solución(), al pertenecer a la clase Resultado, necesitamos primero crear un objeto o instanciar la clase.
solucionInstance = resultado() solucionInstance.solucion(1,2,4)
Un elemento que puede llamar a confusión cuando empiezas en Python es la diferencia entre parámetros y argumentos.
Entenderlo es más sencillo de lo que parece:
Imagina que creas una función que suma dos variables, la variable A y la B
def letras(A, B) return A+B
A y B son parámetros, sin embargo cuando debes llamar la función o el método para ejecutarlo necesitas dar valor a los parámetros cuando los llamas
Si A = 1, B=5
def letras(1, 5)
La función hará lo que está establecido en su comportamiento sumar 1+5
Cuando creamos la clase Resultado al método solución se le pasaron tres parámetros, sin embargo al crear el objeto se pasaron cuatro argumentos, pues se añadió self.
self , es siempre el primer argumento de cualquier clase y hace referencia a ella misma.
Cuando una función es creada por un usuario, se declara siempre igual:
def y luego el nombre de la función, después se añaden los parámetros de la función entre paréntesis y después dos puntos, para terminar la línea. def función(a, b): c=a+b return c
Existen diferentes tipos de argumentos
Los que son por defecto, los requeridos, los argumentos keyword y los variables.
Son que les asigna un valor mediante el operador =
def menos(a,b,d=3): return a-b-d
Esta función puede ser llamada con todos sus parámetros, o solo con alguno de ellos.
#llamandola con 1 parametro menos(b=2)
#llamandola con todos los parametros menos( a=10,b=12,d=4)
Son aquellos que tiene que ser pasados a la función en el momento adecuado y en un orden dado para garantizar su ejecución
En la función menos() a, b y d son argumentos requeridos, los cuales deben pasarse en un momento dado (al inicio) y en un orden ( ya que a-b-d), cambiar ese orden alteraría el resultado.
Este tipo de argumentos son llamados utilizando el parametro al que corresponde para identificarlo
def sol(a,b): return a+b #llamando la función con el uso de keywords def sol(a=2, b=3)
Cuando usamos las keywords, podemos cambiar el orden de los argumentos, sin que ello afecte el resultado
def sol(b=3,a=2)
Se utiliza cuando no se sabe el numero de argumentos esperado, y para ello se utiliza la sintaxis *args
def varios(*args): return sum(args) #ejecutando la función varios(3,6,7)
El asterisco * , se coloca antes del nombre de la variable que soporta los argumentos multiples:
def diferentes(*varnueva): x=2 for i in varnueva: x += i*2 return x
Las variables en Python pueden ser locales o globales, las primeras son las que se definen dentro de las funciones, por tanto solo se puede acceder a ellas desde dentro de la función, mientras que las variables globales puede obtenerla cualquier función.
Return es el encargado de devolver el resultado, ya sea uno o múltiples valores, y su uso nos permite , ampliar las posibilidades de nuestra función o método.
Cuando necesitamos que el return nos devuelva multiples valores, utilizaremos tuplas
Son las funciones que en vez de declararse con def, son declaradas con la palabra lambda.
double = lambda x: x*3 double(5)
En este caso x es el argumento, y x*3 la instrucción que la función debe cumplir
Una función con dos argumentos podría ser
sum = lambda xmy:x+y sum(4,2)
Las funciones anónimas pueden usarse por ejemplo, cuando se requieren funciones con un corto periodo de tiempo de vida, por ejemplo cuando se trabaja con maps(), filter() o reduce().
La función main(), se usa comunenente en Python para agrupar los principales componentes de un sistema.
En un ejemplo sencillo podría ser algo asi:
def main(): varios() solucion() main()
Existe un detalle a considerar, para llamar main() como clase, debe hacerse de esta forma:
__name__ ==’__main__’:
De lo contrario Python asumirá que estamos llamando a un modulo
main() también puede crearse utilizando __init__ para instanciar una clase o un objeto. El nuevo objeto instanciado es asignado al parámetro self
La estructura es esta:
class nueva: """ Requires: atrib_a atrib_b """ def __init__ (self, atrib_a, atrib_b): self.atrib_a =atrib_a self.atrib_b = atrib_b def funcion1(self): funcion1 = …acción…. return funcion1 #llamando a main if __name__ == ”__main__”: solucion = solucion(argumento1, argumento2) funcion1 = solucion.funcion1() print(funcion1)
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
….un sueño es casi todo y más que nada, más que todo al soñarlo, casi nada después……
Para obtener filas aleatorias de la base de datos, ya sea para testear o para ofrecer información que podemos querer incluir en nuestra aplicación Laravel , basta con usar la cláusula OrderByRaw y Rand()
$filas_aleatorias = Filas::orderByRaw('RAND()')->take(10)->get();
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
Subir montañas hermana a los hombres……
Los comandos más importantes de Git, son aquellos que nos ayudan a crear nuestro repositorio, actualizarlo y publicarlo, permitiéndonos su total control, seamos freelance o un equipo de trabajo.
Resumiendo como trabaja git, diré que :
Git controla versiones en un repositorio local, siguiendo una estructura de edición, preparación y confirmación de acciones sobre el.
Cuando estas programando y estas listo para añadir cambios los preparas con git add . que los coloca en estado stage, o sea como una copia instantánea lista, la cual solo valdrá si la confirmas con git commit, o será rechazada si la deshaces con git reset. Esta confirmación se guardará en el historial de proyecto y será entonces si tienes un repositorio remoto cuando usaras git push para enviarlo allí.
No voy a ahondar mucho mas en el tema teorico de que es git, ni porque se necesitas, o no.
Lo cierto es que si trabajas en proyectos cortos, tu solo, y manejas bien las versiones de lo que haces con las carpetas en tu ordenador, bien documentadas, no lo necesitas obligatoriamente, sin embargo si desarrollas junto a un grupo de desarrolladores, con muchos cambios y participación en el código, manejos de variantes, etc , git es una excelente opción.
Los comandos que muestro aquí son solo unos pocos, pero que te permitirán saber como funciona git de modo básico y espero que útil.
Asumo que has instalado git que no tiene mayores complicaciones y estás en la consola.
Ve hastas la carpeta donde esta tu código y escribe
git init
Te creará un repositorio creará un repositorio local vacio, dentro de la carpeta donde tenemos el proyecto, con un mensaje como este
Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra $ git init Initialized empty Git repository in H:/desarrollo/sierra_maestra/.git/
Al mismo tiempo se habrá creado una carpeta oculta llamada .git, que es la encargada de gestionar el repositorio que acabamos de crear. Si quieres dejar de utilizar git, borra esa carpeta y listo, si quieres volver a utilizarlo vuelve a crear el repositorio con : git init
Para ver las carpetas ocultas utiliza el comando: ls -a.
Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master) $ ls -a ./.git/js/'plantilla sierra maestra V1.html' ../css/'Plantilla pag web 1.psd' plantilla-sierra-maestra-1.jpg
Para conocer el estado del repositorio, los commit realizados , escribe
git status
El resultado como no has hecho nada aun en el repositorio será:
Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master) $ git status On branch master No commits yet Untracked files: (use "git add <file>..." to include in what will be committed) Plantilla pag web 1.psd css/ js/ plantilla sierra maestra V1.html plantilla-sierra-maestra-1.jpg nothing added to commit but untracked files present (use "git add" to track)
Lo primero que vemos es “On branch master” esto significa que estamos en la rama principal, es la rama por defecto cuando creamos un repositorio.Git tiene dos procesos para gestionar nuestros archivos. Primero los tenemos que añadir a una zona intermedia conocida como stage y después tenemos que confirmar el paso definitivo de los archivos al repositorio.
Branch : rama de proyecto, puedes crear tantas como desees, y después desecharlas o llevarlas al proyecto
Master: rama original y principal del proyecto y la que ese establece por defecto.
git add .
Importante: Hay que dejar un espacio entre add y el punto”
Con este comando le decimos a git que pase todos los archivos que estén sin pasar al estado stage.
Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master) $ git add . warning: LF will be replaced by CRLF in css/bootstrap-grid.css. The file will have its original line endings in your working directory warning: LF will be replaced by CRLF in css/bootstrap-grid.min.css. The file will have its original line endings in your working directory warning: LF will be replaced by CRLF in css/bootstrap-reboot.css. The file will have its original line endings in your working directory warning: LF will be replaced by CRLF in css/bootstrap-reboot.min.css. ...........
Si ahora volvemos ejecutar el comando git status obtendremos algo como esto:
Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master) $ git status On branch master No commits yet Changes to be committed: (use "git rm --cached <file>..." to unstage) new file: Plantilla pag web 1.psd new file: css/bootstrap-grid.css new file: css/bootstrap-grid.css.map new file: css/bootstrap-grid.min.css new file: css/bootstrap-grid.min.css.map new file: css/bootstrap-reboot.css new file: css/bootstrap-reboot.css.map .............
Para confirmar estos archivos y que pasen definitivamente al repositorio, utilizamos como ya dijimos commit .
Utilizamos el parámetro -m para indicarle una descripción del commit que vamos a hacer, en este caso le decimos que es el commit inicial del proyecto.
Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master) $ git commit -m "Commit inicial del proyecto" [master (root-commit) 9e33f1e] Commit inicial del proyecto 25 files changed, 36210 insertions(+) create mode 100644 Plantilla pag web 1.psd create mode 100644 css/bootstrap-grid.css create mode 100644 css/bootstrap-grid.css.map create mode 100644 css/bootstrap-grid.min.css create mode 100644 css/bootstrap-grid.min.css.map create mode 100644 css/bootstrap-reboot.css create mode 100644 css/bootstrap-reboot.css.map create mode 100644 css/bootstrap-reboot.min.css create mode 100644 css/bootstrap-reboot.min.css.map create mode 100644 css/bootstrap.css create mode 100644 css/bootstrap.css.map .............
Si no indicamos el parámetro -m se abrirá un editor de código de terminal que hayamos definido como editor por defecto puede ser Vim u otro, deberemos escribir el mensaje Si volvemos a ejecutar el comando git status obtendremos este mensaje:
Smart Black Power@DESKTOP-695M5L3 MINGW64 /H/desarrollo/sierra_maestra (master) $ git status On branch master nothing to commit, working tree clean
Esto significa que no hay nada para confirmar, es decir que todos los archivos se encuentran ya en el repositorio.
git add: Añade modificaciones al codigo
commit: Confirma las modificaciones en el código.
Usa: git commit -m”comentarios sobre el commit” como buena practica
Push: añadir un proyecto, código o modificación al repositorio externo, por ejemplo github
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
…., si avanzo sígueme, si me detengo empújame, si retrocedo mátame…….
Cuando en una consulta, necesitamos obtener filas relacionadas, o childrows, podemos hacerlo a través de la combinación de varias cláusulas.
En este caso tenemos un modelo Tareas relacionado con Clientes, en una relación uno a muchos(hasMany). Lo que hará esta consulta que plantea la función getIndex() es consultar la tabla tareas y devolvernos aquellos clientes que poseen tareas asignadas y pasarlos a la vista index, dentro de la carpeta clientes.
class Cliente extends Model
{
public function tareas()
{
return $this->hasMany('App\Tarea');
}
}
public function getIndex()
{
$clientes = Cliente::with('tareas')->has('tareas')->get();
return view('clientes.index', compact('clientes'));
}
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
..Subir montaña hermana hombres…..
Si tenemos una tienda en Prestashop, tal vez querrámos cambiar la descripción de la web incomodo: “tienda desarrollada en Prestashop” , que aparece en Google cuando lista nuestro sitio.
La solución es sencilla:
En el menú busca Preferencias y luego clica en Seo+Urls, te aparecerá una lista de páginas que Prestashop, permite modificar para mejorar el SEO, busca index, ábrelo y edítalo, de acuerdo a tus necesidades y preferencias.
Listo, la próxima vez que el robot de Google indexe tu web, actualizara los cambios y podrás verlos.
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
….un sueño es casi todo y más que nada, más que todo al soñarlo, casi nada después……
La claúsula where tiene muchos usos dentro de Laravel y su uso nos facilita mucho las cosas, y entre ellas crear relaciones condicionales. Algunos de estos casos son:
Puedes crear relaciones condicionales utilizando where. Con el puedes devolver una relación entre, por ejemplo entre los modelos Tareas y Categorias, condicionada esta por el id del usuario
class NombreModelo extends Model
{
public function Tareas()
{
return $this->belongsTo('Categorias', 'categories_id')
->where('users_id', Auth::user()->id);
}
}
Aquí vemos tres formas de tomar todos las tareas correspondientes a la categoría 1, utilizando where y get
$tareas = Tarea::where('categoria', '=', 1)->get();
$tareas = Tarea::where('categoria', 3)->get();
$tareas = Tarea::whereCategoria(3)->get();
Puedes utilizar whereDate para seleccionar o filtrar fechas por diferentes condiciones sea año, día o mes.
$q->whereDate('created_at', date('Y-m-d'));
$q->whereDay('created_at', date('d'));
$q->whereMonth('created_at', date('m'));
$q->whereYear('created_at', date('Y'));
Un ejemplo típico es cuando tenemos que construir una consulta que devuelva resultados dentro de un rango, por ejemplo donde necesitamos recibir solo las tareas de una categoría dada, y que estén relacionadas con una cantidad de usuarios determinados.
Seria algo asi :
... WHERE (tareas = 'tarea1' and cantidadUsuarios >= 5) or (tareas = 'tarea2' and age >= 8)
Lo mas rápido seria construir algo como esto:
$q->where('tareas', 'tarea1');
$q->orWhere('cantidadUsuarios', '>=', 5);
$q->where('tareas', 'tarea2');
$q->orWhere('cantidadUsuarios', '>=', 8);
En esta construcción de la consulta, el orden no es el correcto y podría no ser todo lo eficiente que ncesitamos; la solución en Laravel entonces, pasa por utilizar una función anónima que incluya otras funciones closure como subconsultas:
$q->where(function ($query) {
$query->where('tareas', 'tarea1')
->where('cantidadUsuarios', '>=', 5);
})->orWhere(function($query) {
$query->where('tareas', 'tarea2')
->where('cantidadUsuarios', '>=', 8);
})
De este modo quedan organizadas las consultas en una sola estructura solida e integral, pero al mismo tiempo fácilmente escalable.
Siguiendo con el ejemplo anterior, vemos que utilizamos de modo alterno el Where y el orWhere, pero si los parámetros son múltiples, al estar haciendo algo asi:
$q->where('a', 1);
$q->orWhere('b', 2);
$q->orWhere('c', 3);
Podríamos hacer una consulta un poco larga, la cual podemos acortar, estructurandola asi:
$q->where('a', 1);
$q->orWhere(['b' => 2, 'c' => 3]);
Con Laravel puedes añadir where al nombre del modelo y hacer aun más elegante tus queries, por ejemplo convertir esto :
$users = User::where('tareas', 1)->get();
En esto:
$users = User::whereTarea(1)->get();
Asi de sencillo, y además ya Laravel trae algunos predefinidos como whereDate, whereDay, whereMonth y whereYear, relacionados con date y time, lo cuales se comportan asi:
User::whereDate('created_at', date('Y-m-d'));
User::whereDay('created_at', date('d'));
User::whereMonth('created_at', date('m'));
User::whereYear('created_at', date('Y'));
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
…..lo que realmente importa no es lo que te da la vida, sino lo que haces con ello….
Algunos de los comandos que uso para navegar desde la consola en el mac
ls
ls –a
mkdir nombreCarpeta
cd nombreCarpeta
cd ..
rm –m nombreCarpeta
clear
teclas de flechas, hacia arriba o hacia abajo en dependencia del orden que se desee.
touch documentoNuevo.doc
A veces queremos guardar un archivo recién creado y no nos aparece la ubicación al desplegar save as. Basta con abrir guardar como desplegara las carpetas y podrás escoger donde guardar
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
….subir montañas hermana hombres…..