Il framework Laravel è diventato una risorsa fondamentale per chi realizza servizi web.

Essendo uno strumento open-source, Laravel offre una miriade di funzionalità pronte all’uso che permettono di creare applicazioni robuste e funzionali.

Tra le sue offerte c’è Laravel Scout, una libreria per la gestione degli indici di ricerca dell’applicazione. La sua flessibilità consente a chi sviluppa di di mettere a punto le configurazioni e di scegliere tra i driver Algolia, Meilisearch, MySQL o Postgres per memorizzare gli indici.

In questo articolo esploreremo lo strumento in modo approfondito, mostrandovi come aggiungere il supporto per la ricerca full-text a un’applicazione Laravel attraverso il driver. Modelleremo un’applicazione Laravel demo basata sui dati dei treni: la useremo per memorizzare il nome dei treni e poi con Laravel Scout aggiungeremo una ricerca all’applicazione.

Prerequisiti

Per seguire questo tutorial dovete avere:

  • Il compiler PHP installato sul vostro computer. Questo tutorial usa la versione 8.1 di PHP.
  • Il motore Docker o Docker Desktop installato sul vostro computer.
  • Un account Algolia cloud, che potete creare gratuitamente.

Come installare Scout in un progetto Laravel

Per usare Scout, dovete prima creare un’applicazione Laravel in cui volete aggiungere la funzionalità di ricerca. Lo script Laravel-Scout Bash contiene i comandi per generare un’applicazione Laravel all’interno di un container Docker. L’utilizzo di Docker vi permette di non dover installare altri software di supporto, come per esempio un database MySQL.

Lo script Laravel-Scout usa il linguaggio di scripting Bash, quindi dovete eseguirlo in ambiente Linux. Se usate Windows, verificate di configurare Windows Subsystem for Linux (WSL).

Se usate WSL, eseguite il seguente comando nel terminale per impostare la vostra distribuzione Linux preferita.

wsl -s ubuntu

Successivamente, navigate nella posizione del computer in cui volete collocare il progetto. Lo script Laravel-Scout genererà una cartella del progetto in questa posizione. Nell’esempio seguente, lo script Laravel-Scout creerà una directory all’interno della directory desktop.

cd /desktop

Utilizzate il comando seguente per eseguire lo script Laravel-Scout. Verrà creata un’applicazione Dockerizzata con il codice di base necessario.

curl -s https://laravel.build/laravel-scout-app | bash

Dopo l’esecuzione, cambiate la vostra cartella usando cd laravel-scout-app. Quindi, eseguite il comando sail-up all’interno della cartella del progetto per avviare i container Docker della vostra applicazione.

Nota: Su molte distribuzioni Linux, potrebbe essere necessario eseguire il comando sottostante con il comando sudo per avviare i privilegi elevati.

./vendor/bin/sail up

Potrebbe verificarsi un errore:

Messaggio di errore che dice "failed: port is already allocated"
Errore che dichiara che la porta è allocata.

Per risolvere questo problema, usate la variabile APP_PORT per specificare una porta all’interno del comando sail up:

APP_PORT=3001 ./vendor/bin/sail up

Quindi, eseguite l’applicazione attraverso Artisan sul server PHP con il comando seguente.

php artisan serve
Scherma di un editor che mostra che l’applicazione Laravel servita con Artisan
Servire l’applicazione Laravel con Artisan

Dal vostro browser web, navigate verso l’applicazione in esecuzione all’indirizzo http://127.0.0.1:8000. L’applicazione visualizzerà la pagina di benvenuto di Laravel sul percorso predefinito.

Schermata del sito di Laravel con la pagina di bevenuto
Pagina di benvenuto dell’applicazione Laravel

Come aggiungere Laravel Scout all’applicazione

Nel vostro terminale, inserite il comando che abilita il gestore di pacchetti PHP Composer ad aggiungere Laravel Scout al progetto.

composer require laravel/scout

Successivamente, pubblicate il file di configurazione di Scout utilizzando il comando vendor:publish.
Il comando pubblicherà il file di configurazione scout.php nella directory config della vostra applicazione.

 php artisan vendor:publish --provider="LaravelScoutScoutServiceProvider"

Ora, modificate il file boilerplate .env in modo che contenga un valore booleano SCOUT_QUEUE.

Il valore SCOUT_QUEUE permette a Scout di mettere in coda le operazioni, garantendo tempi di risposta migliori. Senza questo valore, i driver di Scout, come Meilisearch, non rifletteranno immediatamente i nuovi record.

SCOUT_QUEUE=true

Inoltre, modificate la variabile DB_HOST nel file .env in modo che punti al vostro localhost per usare il database MySQL all’interno dei container Docker.

DB_HOST=127.0.0.1

Come contrassegnare un modello e configurare l’indice

Scout non abilita i modelli di dati ricercabili per impostazione predefinita. Dovete contrassegnare esplicitamente un modello come ricercabile usando il suo tratto LaravelScoutSearchable.

Inizierete creando un modello di dati per un’applicazione demo di Train e contrassegnandolo come ricercabile.

Come creare un modello

Per l’applicazione Train, dovrete memorizzare i nomi segnaposto di ogni treno disponibile.

Eseguite il comando Artisan qui sotto per generare la migrazione e chiamatela create_trains_table.

php artisan make:migration create_trains_table
Schermata dell’editor con il codice per creare una migrazione denominata create_trains_table
Creare una migrazione denominata create_trains_table

La migrazione verrà generata in un file il cui nome combina il nome specificato e il timestamp corrente.

Aprite il file di migrazione che si trova nella directory database/migrations/.

Per aggiungere una colonna titolo (title), aggiungete il seguente codice dopo la colonna id() nella riga 17. Il codice aggiungerà una colonna title.

$table->string('title');

Per applicare la migrazione, eseguite il comando seguente.

php artisan migrate
Schermata con l’applicazione della migrazione Artisan
Applicare la migrazione Artisan

Dopo aver eseguito la migrazione del database, create un file chiamato Train.php nella cartella app/Models/.

Come aggiungere il tratto LaravelScoutSearchable

Marcate il modello Train per la ricerca aggiungendo il tratto LaravelScoutSearchable al modello, come mostrato di seguito.

<?php
namespace AppModels;
use IlluminateDatabaseEloquentModel;
use LaravelScoutSearchable;

class Train extends Model
{
	use Searchable;
	public $fillable = ['title'];

Inoltre, dovete configurare gli indici di ricerca sovrascrivendo il metodo searchable. Il comportamento predefinito di Scout prevede la persistenza del modello in base al nome della tabella del modello.

Quindi, aggiungete il seguente codice al file Train.php sotto il codice del blocco precedente.

/**
 	* Retrieve the index name for the model.
 	*
 	* @return string
	*/
	public function searchableAs()
	{
    	return 'trains_index';
   }
}

Come usare Algolia con Scout

Per la prima ricerca full-text con Laravel Scout, userete il driver Algolia. Algolia è una piattaforma SaaS (Software as a Service) utilizzata per la ricerca di grandi quantità di dati. Fornisce a chi sviluppa una bacheca web per gestire gli indici di ricerca e una solida API a cui potete accedere tramite un kit di sviluppo software (SDK) nel vostro linguaggio di programmazione preferito.

All’interno dell’applicazione Laravel, userete il pacchetto client Algolia per PHP.

Come configurare Algolia

Per prima cosa, dovete installare il pacchetto client di ricerca per PHP Algolia per la vostra applicazione.

Eseguite il comando seguente.

composer require algolia/algoliasearch-client-php

Successivamente, dovete impostare le credenziali dell’Application ID e della Secret API Key di Algolia nel file .env.

Con il vostro browser web, entrate nella bacheca di Algolia per ottenere le credenziali dell’Application ID e della Secret API Key.

Fate clic su Settings in fondo alla barra laterale di sinistra per accedere alla pagina Settings.

Andate quindi su API Keys nella sezione Team and Access della pagina Settings per visualizzare le chiavi del vostro account Algolia.

Schermata dell’interfaccia di Algolia Cloud e della pagina Team and Access: è evidenziato il pulsante API Keys
Pagina API Keys su Algolia Cloud

Nella pagina API Keys, prendete nota dei valori dell’Application ID e dell’Admin API Key. Userete queste credenziali per autenticare la connessione tra l’applicazione Laravel e Algolia.

Schermata della pagina API Keys da cui visualizzare Application ID e Admin API Keys
Application ID e Admin API

Aggiungete il codice seguente al vostro file .env utilizzando il vostro editor di codice e sostituite i segnaposto con i corrispondenti API secrets di Algolia.

ALGOLIA_APP_ID=APPLICATION_ID
ALGOLIA_SECRET=ADMIN_API_KEY

Inoltre, sostituite la variabile SCOUT_DRIVER con il codice sottostante per cambiare il valore da meilisearch a algolia. La modifica di questo valore indicherà a Scout di usare il driver Algolia.

SCOUT_DRIVER=algolia

Come creare i controller dell’applicazione

All’interno della cartella app/Http/Controllers/, create un file TrainSearchController.php per memorizzare un controller per l’applicazione. Il controller elencherà e aggiungerà dati al modello Train.

Aggiungete il seguente blocco di codice nel file TrainSearchController.php per creare il controller.

<?php
namespace AppHttpControllers;
use IlluminateHttpRequest;
use AppHttpRequests;
use AppModelsTrain;

class TrainSearchController extends Controller
{
	/**
 	* Get the index name for the model.
 	*
 	* @return string
	*/
	public function index(Request $request)
	{
    	if($request->has('titlesearch')){
        	$trains = Train::search($request->titlesearch)
            	->paginate(6);
    	}else{
        	$trains = Train::paginate(6);
    	}
    	return view('Train-search',compact('trains'));
	}

	/**
 	* Get the index name for the model.
 	*
 	* @return string
	*/
	public function create(Request $request)
	{
    	$this->validate($request,['title'=>'required']);

    	$trains = Train::create($request->all());
    	return back();
	}
}

Come creare le route dell’applicazione

In questo passaggio creeremo le route per elencare e aggiungere nuovi treni al database.

Aprite il file routes/web.php e sostituite il codice esistente con il blocco sottostante.

<?php

use IlluminateSupportFacadesRoute;
use AppHttpControllersTrainSearchController;

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

Route::get('trains-lists', [TrainSearchController::class, 'index']) -> name ('trains-lists');

Route::post('create-item', [TrainSearchController::class, 'create']) -> name ('create-item');

Il codice precedente definisce due percorsi nell’applicazione. La richiesta GET per il percorso /trains-lists elenca tutti i dati dei treni memorizzati. La richiesta POST per la route /create-item crea nuovi dati sui treni.

Come creare le viste dell’applicazione

Create un file nella cartella resources/views/ e chiamatelo Train-search.blade.php. Il file mostrerà l’interfaccia utente della funzionalità di ricerca.

Aggiungete il contenuto del blocco di codice sottostante nel file Train-search.blade.php per creare una singola pagina per la funzionalità di ricerca.

<!DOCTYPE html>
<html>
<head>
	<title>Laravel - Laravel Scout Algolia Search Example</title>
	<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
</head>
<body>
<div class="container">
	<h2 class="text-bold">Laravel Full-Text Search Using Scout </h2><br/>
	<form method="POST" action="{{ route('create-item') }}" autocomplete="off">
    	@if(count($errors))
        	<div class="alert alert-danger">
            	<strong>Whoops!</strong> There is an error with your input.
            	<br/>
            	<ul>
                	@foreach($errors->all() as $error)
                	<li>{{ $error }}</li>
                	@endforeach
            	</ul>
        	</div>
    	@endif

    	<input type="hidden" name="_token" value="{{ csrf_token() }}">

    	<div class="row">
        	<div class="col-md-6">
            	<div class="form-group {{ $errors->has('title') ? 'has-error' : '' }}">
                	<input type="text" id="title" name="title" class="form-control" placeholder="Enter Title" value="{{ old('title') }}">
                	<span class="text-danger">{{ $errors->first('title') }}</span>
            	</div>
        	</div>
        	<div class="col-md-6">
            	<div class="form-group">
                	<button class="btn btn-primary">Create New Train</button>
            	</div>
        	</div>
    	</div>
	</form>

	<div class="panel panel-primary">
  	<div class="panel-heading">Train Management</div>
  	<div class="panel-body">
        	<form method="GET" action="{{ route('trains-lists') }}">

            	<div class="row">
                	<div class="col-md-6">
                    	<div class="form-group">
                        	<input type="text" name="titlesearch" class="form-control" placeholder="Enter Title For Search" value="{{ old('titlesearch') }}">
                    	</div>
                	</div>
                	<div class="col-md-6">
                    	<div class="form-group">
                        	<button class="btn btn-primary">Search</button>
                    	</div>
                	</div>
            	</div>
        	</form>

        	<table class="table">
            	<thead>
                	<th>Id</th>
                	<th>Train Title</th>
                	<th>Creation Date</th>
                	<th>Updated Date</th>
            	</thead>
            	<tbody>
                	@if($trains->count())
                    	@foreach($trains as $key => $item)
                        	<tr>
                            	<td>{{ ++$key }}</td>
                            	<td>{{ $item->title }}</td>
                            	<td>{{ $item->created_at }}</td>
                            	<td>{{ $item->updated_at }}</td>
                        	</tr>
                    	@endforeach
                	@else
                    	<tr>
                        	<td colspan="4">No train data available</td>
                    	</tr>
                	@endif
            	</tbody>
        	</table>
        	{{ $trains->links() }}
  	</div>
	</div>
</div>
</body>
</html>

Il codice HTML qui sopra contiene un elemento modulo con un campo di input e un pulsante per digitare il titolo di un treno prima di salvarlo nel database. Il codice contiene anche una tabella HTML con i campi id, title, created_at e updated_at di un treno all’interno del database.

Come usare la ricerca di Algolia

Per visualizzare la pagina, navigate su http://127.0.0.1:8000/trains-lists dal vostro browser web.

Visualizzazione su Laravel Scout Algolia del modello nella pagina trains-lists page
Dati del modello di treno

Il database al momento è vuoto, quindi dovete inserire il titolo di un treno demo nel campo di input e fare clic su Create New Train per salvarlo.

Visualizzazione su Laravel Scout Algolia del campo per inserire un nuovo treno
Inserimento di un nuovo treno

Per usare la funzione di ricerca, digitate una parola chiave tra i titoli dei treni salvati nel campo di immissione Enter Title For Search e fate clic su Search.

Come mostrato nell’immagine seguente, verranno visualizzate solo le voci di ricerca che contengono la parola chiave nel titolo.

Visualizzazione su Laravel Scout Algolia del campo di ricercare per trovare un treno
Usare la funzione di ricerca per trovare un treno

Meilisearch con Laravel Scout

Meilisearch è un motore di ricerca open-source che si concentra sulla velocità, sulle prestazioni e sul miglioramento dell’esperienza di sviluppo. Condivide diverse caratteristiche con Algolia, usa gli stessi algoritmi, le stesse strutture dati e le stesse ricerche, ma con un linguaggio di programmazione diverso.

Potete creare e ospitare autonomamente un’istanza di Meilisearch all’interno della vostra infrastruttura on-premises o cloud. Meilisearch ha anche un’offerta cloud beta simile ad Algolia per chi vuole usare il prodotto senza gestirne l’infrastruttura.

Nel tutorial, avete già un’istanza locale di Meilisearch in esecuzione nei vostri container Docker. Ora estenderete la funzionalità di Laravel Scout per usare l’istanza di Meilisearch.

Per aggiungere Meilisearch all’applicazione Laravel, eseguite il comando seguente nel terminale del progetto.

composer require meilisearch/meilisearch-php

Successivamente, dovrete modificare le variabili di Meilisearch all’interno del file .env per configurarlo.

Sostituite le variabili SCOUT_DRIVER, MEILISEARCH_HOST e MEILISEARCH_KEY nel file .env con le seguenti.

SCOUT_DRIVER=meilisearch
MEILISEARCH_HOST=http://127.0.0.1:7700
MEILISEARCH_KEY=LockKey

La chiave SCOUT_DRIVER specifica il driver che Scout deve usare, mentre MEILISEARCH_HOST rappresenta il dominio in cui è in esecuzione la vostra istanza di Meilisearch. Anche se non è necessario durante lo sviluppo, vi consigliamo di aggiungere la variabile MEILISEARCH_KEY in produzione.

Nota: Se usate Meilisearch come driver preferenziale, commentate l’ID e il Secret di Algolia.

Dopo aver completato le configurazioni .env, dovete indicizzare i record preesistenti usando il comando Artisan riportato di seguito.

php artisan scout:import "AppModelsTrain"

Laravel Scout con il motore di database

Il motore di database di Scout potrebbe essere più adatto alle applicazioni che usano database più piccoli o che gestiscono carichi di lavoro meno intensivi. Al momento, il motore di database supporta PostgreSQL e MySQL.

Questo motore usa clausole “where-like” e indici full-text sul vostro database esistente, consentendogli di trovare i risultati di ricerca più rilevanti. Non è necessario indicizzare i record quando si usa il motore di database.

Per usare il motore di database, dovete impostare la variabile SCOUT_DRIVER .env sul database.

Aprite il file .env all’interno dell’applicazione Laravel e modificate il valore della variabile SCOUT_DRIVER.

SCOUT_DRIVER = database

Dopo aver modificato il driver del database, Scout passerà a usare il motore del database per la ricerca full-text.

Motore di raccolta con Laravel Scout

Oltre al motore del database, Scout offre anche un motore di raccolta. Questo motore usa le clausole “where” e il filtraggio delle raccolte per estrarre i risultati di ricerca più rilevanti.

A differenza del motore di database, il motore di raccolta supporta tutti i database relazionali supportati anche da Laravel.

Potete usare il motore di raccolta impostando la variabile d’ambiente SCOUT_DRIVER a collection o specificando manualmente il driver di raccolta nel file di configurazione di Scout.

SCOUT_DRIVER = collection

Explorer con Elasticsearch

Grazie alla forza delle query Elasticsearch, Explorer è un moderno driver Elasticsearch per Laravel Scout. Offre un driver Scout compatibile e vantaggi come l’archiviazione, la ricerca e l’analisi di enormi quantità di dati in tempo reale. Elasticsearch con Laravel offre risultati in millisecondi.

Per usare il driver Elasticsearch Explorer nell’applicazione Laravel, dovrete configurare il file boilerplate docker-compose.yml generato dallo script Laravel-Scout. Dovrete aggiungere le configurazioni aggiuntive per Elasticsearch e riavviare i container.

Aprite il file docker-compose.yml e sostituite il suo contenuto con il seguente.

# For more information: https://laravel.com/docs/sail
version: '3'
services:
	laravel.test:
    	build:
        	context: ./vendor/laravel/sail/runtimes/8.1
        	dockerfile: Dockerfile
        	args:
            	WWWGROUP: '${WWWGROUP}'
    	image: sail-8.1/app
    	extra_hosts:
        	- 'host.docker.internal:host-gateway'
    	ports:
        	- '${APP_PORT:-80}:80'
        	- '${VITE_PORT:-5173}:${VITE_PORT:-5173}'
    	environment:
        	WWWUSER: '${WWWUSER}'
        	LARAVEL_SAIL: 1
        	XDEBUG_MODE: '${SAIL_XDEBUG_MODE:-off}'
        	XDEBUG_CONFIG: '${SAIL_XDEBUG_CONFIG:-client_host=host.docker.internal}'
    	volumes:
        	- '.:/var/www/html'
    	networks:
        	- sail
    	depends_on:
        	- mysql
        	- redis
        	- meilisearch
        	- mailhog
        	- selenium
        	- pgsql
        	- elasticsearch

	mysql:
    	image: 'mysql/mysql-server:8.0'
    	ports:
        	- '${FORWARD_DB_PORT:-3306}:3306'
    	environment:
        	MYSQL_ROOT_PASSWORD: '${DB_PASSWORD}'
        	MYSQL_ROOT_HOST: "%"
        	MYSQL_DATABASE: '${DB_DATABASE}'
        	MYSQL_USER: '${DB_USERNAME}'
        	MYSQL_PASSWORD: '${DB_PASSWORD}'
        	MYSQL_ALLOW_EMPTY_PASSWORD: 1
    	volumes:
        	- 'sail-mysql:/var/lib/mysql'
        	- './vendor/laravel/sail/database/mysql/create-testing-database.sh:/docker-entrypoint-initdb.d/10-create-testing-database.sh'
    	networks:
        	- sail
    	healthcheck:
        	test: ["CMD", "mysqladmin", "ping", "-p${DB_PASSWORD}"]
        	retries: 3
        	timeout: 5s
       	 
	elasticsearch:
    	image: 'elasticsearch:7.13.4'
    	environment:
        	- discovery.type=single-node
    	ports:
        	- '9200:9200'
        	- '9300:9300'
    	volumes:
        	- 'sailelasticsearch:/usr/share/elasticsearch/data'
    	networks:
        	- sail
	kibana:
    	image: 'kibana:7.13.4'
    	environment:
        	- elasticsearch.hosts=http://elasticsearch:9200
    	ports:
        	- '5601:5601'
    	networks:
        	- sail
    	depends_on:
        	- elasticsearch
	redis:
    	image: 'redis:alpine'
    	ports:
        	- '${FORWARD_REDIS_PORT:-6379}:6379'
    	volumes:
        	- 'sail-redis:/data'
    	networks:
        	- sail
    	healthcheck:
        	test: ["CMD", "redis-cli", "ping"]
        	retries: 3
        	timeout: 5s
	pgsql:
    	image: 'postgres:13'
    	ports:
        	- '${FORWARD_DB_PORT:-5432}:5432'
    	environment:
        	PGPASSWORD: '${DB_PASSWORD:-secret}'
        	POSTGRES_DB: '${DB_DATABASE}'
        	POSTGRES_USER: '${DB_USERNAME}'
        	POSTGRES_PASSWORD: '${DB_PASSWORD:-secret}'
    	volumes:
        	- 'sailpgsql:/var/lib/postgresql/data'
    	networks:
        	- sail
    	healthcheck:
        	test: ["CMD", "pg_isready", "-q", "-d", "${DB_DATABASE}", "-U", "${DB_USERNAME}"]
        	retries: 3
        	timeout: 5s
	meilisearch:
    	image: 'getmeili/meilisearch:latest'
    	ports:
        	- '${FORWARD_MEILISEARCH_PORT:-7700}:7700'
    	volumes:
        	- 'sail-meilisearch:/meili_data'
    	networks:
        	- sail
    	healthcheck:
        	test: ["CMD", "wget", "--no-verbose", "--spider",  "http://localhost:7700/health"]
        	retries: 3
        	timeout: 5s
	mailhog:
    	image: 'mailhog/mailhog:latest'
    	ports:
        	- '${FORWARD_MAILHOG_PORT:-1025}:1025'
        	- '${FORWARD_MAILHOG_DASHBOARD_PORT:-8025}:8025'
    	networks:
        	- sail
	selenium:
    	image: 'selenium/standalone-chrome'
    	extra_hosts:
        	- 'host.docker.internal:host-gateway'
    	volumes:
        	- '/dev/shm:/dev/shm'
    	networks:
        	- sail
networks:
	sail:
    	driver: bridge
volumes:
	sail-mysql:
    	driver: local
	sail-redis:
    	driver: local
	sail-meilisearch:
    	driver: local
	sailpgsql:
    	driver: local
	sailelasticsearch:
    	driver: local

Quindi, eseguite il comando seguente per estrarre la nuova immagine di Elasticsearch che avete aggiunto al file docker-compose.yml.

docker-compose up

Ora eseguite il comando Composer qui sotto per installare Explorer nel progetto.

composer require jeroen-g/explorer

Dovete anche creare un file di configurazione per il driver di Explorer.

Eseguite il comando Artisan qui sotto per generare un file explorer.config per memorizzare le configurazioni.

php artisan vendor:publish --tag=explorer.config

Il file di configurazione generato sopra sarà disponibile nella directory /config.

Nel file config/explorer.php potete fare riferimento al vostro modello usando la chiave indexes.

'indexes' => [
    	AppModelsTrain::class
],

Cambiate il valore della variabile SCOUT_DRIVER nel file .env in elastic per configurare Scout in modo che usi il driver Explorer.

SCOUT_DRIVER = elastic

A questo punto, userete Explorer all’interno del modello Train implementando l’interfaccia Explorer e sovrascrivendo il metodo mappableAs().

Aprite il file Train.php nella cartella App > Models e sostituite il codice esistente con il codice seguente.

<?php
namespace AppModels;
 
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use JeroenGExplorerApplicationExplored;
use LaravelScoutSearchable;
 
class Train extends Model implements Explored
{
	use HasFactory;
	use Searchable;
 
	protected $fillable = ['title'];
 
	public function mappableAs(): array
	{
    	return [
   		 'id'=>$this->Id,
   		 'title' => $this->title,
    	];
	}
}

Con il codice aggiunto sopra, ora potete usare Explorer per cercare il testo all’interno del modello Train.

Riepilogo

Per chi sviluppa in PHP, Laravel e i componenti aggiuntivi come Scout semplificano l’integrazione di funzionalità di ricerca full-text veloci e robuste. Grazie al Database Engine, al Collection Engine e alle funzionalità di Meilisearch ed Elasticsearch, potete interagire con il database della vostra applicazione e implementare meccanismi di ricerca avanzati in pochi millisecondi.

Grazie alla gestione e all’aggiornamento del database, i vostri utenti avranno un’esperienza ottimale e il vostro codice rimarrà pulito ed efficiente.

Con le nostre soluzioni di Hosting di Applicazioni e Database, Kinsta è il punto di riferimento unico per tutte le esigenze di sviluppo con Laravel. I primi 20 dollari li offriamo noi.

Jeremy Holcombe Kinsta

Content & Marketing Editor presso Kinsta, web developer di WordPress e content writer. Al di fuori di tutto ciò che riguarda WordPress, mi piacciono la spiaggia, il golf e il cinema. Ho anche i problemi di tutte le persone più alte della media ;).