લારાવેલમાં રીઅલ-ટાઇમ શોધ માટે સંપૂર્ણ માર્ગદર્શિકા

ઇન્ફોર્મેટેક ડિજિટલ » સંપત્તિ » લારાવેલમાં રીઅલ-ટાઇમ શોધ માટે સંપૂર્ણ માર્ગદર્શિકા

જ્યારે તમે Laravel સાથે કામ કરવાનું શરૂ કરો છો અને જરૂર પડે છે રીઅલ-ટાઇમ સર્ચ એન્જિન જે તરત જ જવાબ આપે છેહજારો સંભવિત અભિગમો વચ્ચે ખોવાઈ જવું સરળ છે: ફેચ સાથે AJAX, jQuery, Alpine.js, અલ્ગોલિયા અથવા મેઇલિસર્ચ સાથે સ્કાઉટ, ફ્રન્ટએન્ડ ફિલ્ટરિંગ, વગેરે. સારા સમાચાર એ છે કે લારાવેલ ઇકોસિસ્ટમ પહેલાથી જ તમને પ્રયાસમાં મર્યા વિના સરળ અને ઝડપી શોધ સેટ કરવા માટે જરૂરી બધું જ પ્રદાન કરે છે.

આ લેખમાં તમે જોશો કે કેવી રીતે એસેમ્બલ કરવું લારાવેલમાં રીઅલ-ટાઇમ શોધના વિવિધ પ્રકારોક્લાસિક AJAX ઓટોકમ્પ્લીટથી લઈને Laravel Scout અને Algolia, Meilisearch, ડેટાબેઝ પોતે, અથવા તો Elasticsearch જેવા સર્ચ એન્જિન સાથે પૂર્ણ-ટેક્સ્ટ શોધ સુધી. જ્યારે ડેટા વોલ્યુમ ઓછું હોય ત્યારે બ્રાઉઝરમાં સીધા ડેટા ફિલ્ટર કરવા માટે તમને Alpine.js સાથે હળવા વિકલ્પો પણ દેખાશે.

લારાવેલમાં રીઅલ-ટાઇમ સર્ચ શું છે અને મૂળભૂત બાબતો કેવી રીતે કાર્ય કરે છે?

રીઅલ-ટાઇમ શોધ પાછળનો વિચાર એ છે કે, જેમ વપરાશકર્તા ટેક્સ્ટ ફીલ્ડમાં ટાઇપ કરે છેએક ક્વેરી શરૂ થાય છે અને પૃષ્ઠને ફરીથી લોડ કર્યા વિના પરિણામો અપડેટ કરવામાં આવે છે. તકનીકી રીતે, આમાં ત્રણ મુખ્ય ઘટકોનો સમાવેશ થાય છે: લારાવેલ બેકએન્ડ, બ્રાઉઝરનું જાવાસ્ક્રિપ્ટ અને JSON ફોર્મેટમાં ડેટાનું વિનિમય.

એક તરફ, લારાવેલ સર્વર લેયર તરીકે કાર્ય કરે છે તે વિનંતીઓ પ્રાપ્ત કરવા, શોધ પરિમાણો (દાખલ કરેલ ટેક્સ્ટ) નું અર્થઘટન કરવા, ડેટાબેઝને ક્વેરી કરવા અને સામાન્ય રીતે JSON ફોર્મેટમાં સ્ટ્રક્ચર્ડ પ્રતિભાવ પરત કરવા માટે જવાબદાર છે. આ પ્રતિભાવ સફળતા, ભૂલ અથવા કોઈ પરિણામ મળ્યું ન હોવાનું સૂચવી શકે છે.

બીજા છેડે, જાવાસ્ક્રિપ્ટ વપરાશકર્તાની ઘટનાઓ સાંભળવા માટે જવાબદાર છે. શોધ ઇનપુટ પર, બેકએન્ડ પર અસિંક્રોનસ વિનંતીઓ (AJAX) મોકલો અને બ્રાઉઝર સંપૂર્ણ રિફ્રેશ કર્યા વિના પૃષ્ઠ પર પરત થયેલ ડેટા પ્રદર્શિત કરો. આ નેટિવ ફેચ, jQuery AJAX અથવા Alpine.js જેવી નાની પ્રતિક્રિયાશીલ લાઇબ્રેરીઓ સાથે કરી શકાય છે.

આ મૂળભૂત પદ્ધતિ સાથે તમે બનાવી શકો છો થોડા રેકોર્ડ સાથે સરળ સ્વતઃપૂર્ણ, સુસંગતતા, પૃષ્ઠ ક્રમાંકન અને ફિલ્ટર્સ સાથે અદ્યતન પૂર્ણ-ટેક્સ્ટ સર્ચ એન્જિન સુધી, જે લારાવેલ સ્કાઉટ જેવી લાઇબ્રેરીઓ અને શોધ માટે ઑપ્ટિમાઇઝ કરેલા બાહ્ય સર્ચ એન્જિન દ્વારા સમર્થિત છે.

મૂળભૂત રીઅલ-ટાઇમ સર્ચ એન્જિન માટે મોડેલ, રૂટ્સ અને નિયંત્રક

જાવાસ્ક્રિપ્ટમાં ઊંડા ઉતરતા પહેલા, તમારે ખાતરી કરવાની જરૂર છે કે લારાવેલ બાજુ સારી રીતે ગોઠવાયેલી છે: શોધવા માટે એક છટાદાર મોડેલ, સ્પષ્ટ રૂટ અને સમર્પિત નિયંત્રક રીઅલ ટાઇમમાં શોધ તર્કનું સંચાલન કરવા માટે.

પહેલું પગલું એ છે કે એક એલોક્વન્ટ મોડેલ હોવું જોઈએ જે તમે જ્યાં શોધવા જઈ રહ્યા છો તે કોષ્ટકનું પ્રતિનિધિત્વ કરે. દેશોના કોષ્ટક અને એક મોડેલની કલ્પના કરો જેને દેશ ખૂબ જ સરળ, ટાઇમસ્ટેમ્પ વિના અને બલ્ક સોંપણી સાથે મંજૂરી છે:

શોધ માટે ન્યૂનતમ વાક્છટાદાર મોડેલનું ઉદાહરણ:

namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Pais extends Model
{
use HasFactory;
protected $guarded = [];
public $timestamps = false;
}

અહીં સૂચવવામાં આવ્યું છે કે મોડેલ પેઇસ પ્રમાણભૂત લારાવેલ નેમસ્પેસમાં સ્થિત છેતે મોડેલમાંથી વારસામાં મળે છે અને તમને રક્ષિત એરે ખાલી છોડીને create() સાથે કોઈપણ ફીલ્ડ સોંપવાની મંજૂરી આપે છે. public $timestamps = false સાથે ટાઇમસ્ટેમ્પ્સને અક્ષમ કરીને, જો ટેબલમાં created_at અને updated_at કૉલમ ન હોય તો તમે સમસ્યાઓ ટાળી શકો છો.

આગળનું પગલું એ વ્યાખ્યાયિત કરવાનું છે સર્ચ એન્જિન ડિસ્પ્લે અને AJAX વિનંતીઓ બંનેને હેન્ડલ કરશે તેવા રૂટ્સએક ખૂબ જ સામાન્ય યોજનામાં વ્યૂ દર્શાવવા માટે GET રૂટ અને રીઅલ-ટાઇમ ક્વેરીઝ પ્રાપ્ત કરવા માટે રચાયેલ POST રૂટનો સમાવેશ થાય છે:

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\BuscadorController;

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

Route::get('buscador', [BuscadorController::class, 'index']);
Route::post('buscador', [BuscadorController::class, 'buscar']);

રૂટ રૂટ સ્વાગત દૃશ્ય આપે છે, જ્યારે URL /search શોધ કાર્યક્ષમતા માટે આરક્ષિત છેકંટ્રોલરની index() પદ્ધતિ ફોર્મ અને શોધ ઇનપુટ દર્શાવે છે, જ્યારે search() પદ્ધતિ બ્રાઉઝરમાંથી મોકલવામાં આવેલી અસુમેળ વિનંતીઓ પર પ્રક્રિયા કરે છે.

કંટ્રોલરમાં તમે ખૂબ જ વ્યવહારુ પેટર્ન અમલમાં મૂકી શકો છો: ભૂલના કિસ્સામાં ડિફોલ્ટ પ્રતિભાવ શ્રેણી તૈયાર કરો. અને તેને ફક્ત ત્યારે જ ઓવરરાઇટ કરો જ્યારે તે ખરેખર માન્ય AJAX વિનંતી હોય અને ક્વેરી સમસ્યા વિના એક્ઝિક્યુટ થાય.

નિયંત્રક પાસે હોઈ શકે છે સમાન માળખું આ:

namespace App\Http\Controllers;

use App\Models\Pais;
use Illuminate\Http\Request;

class BuscadorController extends Controller
{
public function index()
{
return view('welcome');
}

public function buscar(Request $request)
{
$response = [
'success' => false,
'message' => 'Hubo un error',
];

if ($request->ajax()) {
$data = Pais::where('nombre', 'like', $request->texto.'%')
->take(10)
->get();

$response = [
'success' => true,
'message' => 'Consulta correcta',
'data' => $data,
];
}

return response()->json($response);
}
}

આ બિંદુએ તમારી પાસે પહેલેથી જ છે સંપૂર્ણ બેકએન્ડ ચક્ર: આવનારી AJAX વિનંતી, તે AJAX છે કે નહીં તે તપાસવું, ગમે ત્યાં ક્વેરી કરવી અને પરિણામો મર્યાદિત કરવા ડેટાબેઝ ઓવરલોડિંગ ટાળવા માટે take(10) નો ઉપયોગ કરીને વાજબી સંખ્યામાં મોકલવામાં આવે છે. પ્રતિભાવ હંમેશા JSON માં મોકલવામાં આવે છે, જે ફ્રન્ટએન્ડના કાર્યને મોટા પ્રમાણમાં સરળ બનાવે છે.

પ્રતિક્રિયાશીલ શોધ માટે બ્લેડ વ્યૂ અને જાવાસ્ક્રિપ્ટ ફેચ

મોડેલ, રૂટ્સ અને કંટ્રોલર તૈયાર થયા પછી, દૃશ્યમાન ભાગ બનાવવાનો સમય આવી ગયો છે: શોધ ક્ષેત્ર અને પરિણામો દર્શાવવા માટે બ્લોક સાથેનું ફોર્મ, વત્તા પૃષ્ઠભૂમિમાં વિનંતીઓ કરવા માટે જવાબદાર JavaScript.

બ્લેડ વ્યૂ ખૂબ જ સરળ હોઈ શકે છે, તેના પર આધાર રાખીને CSRF ટોકન જે લારાવેલ POST વિનંતીઓને માન્ય કરવા માટે અને ઉપયોગમાં સરળ શોધ ઇનપુટમાં ઇન્જેક્ટ કરે છે:

<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<strong><meta name="csrf-token" content="{{ csrf_token() }}"></strong>
<title>Laravel</title>
</head>
<body>

<form action="" method="post">
<input type="search" name="texto" id="buscar">
</form>

<div id="resultado"></div>

<script>
window.addEventListener('load', function () {
const buscar = document.getElementById('buscar');
const resultado = document.getElementById('resultado');

buscar.addEventListener('keyup', function () {
fetch('/buscador', {
method: 'post',
body: JSON.stringify({ texto: buscar.value }),
headers: {
'Content-Type': 'application/json',
'X-Requested-With': 'XMLHttpRequest',
'X-CSRF-Token': document.head.querySelector('[name~="csrf-token"][content]').content,
},
})
.then(response => response.json())
.then(data => {
let html = '';
if (data.success) {
html += '<ul>';
for (let i in data.data) {
html += '<li>' + data.data[i].nombre + '</li>';
}
html += '<ul>';
} else {
html += 'No existen resultados';
}
resultado.innerHTML = html;
});
});
});
</script>

</body>
</html>

આ ઉદાહરણમાં સ્ક્રિપ્ટ શોધ ઇનપુટ પર કીઅપ ઇવેન્ટ સાંભળોદરેક કીસ્ટ્રોક /search પાથ પર ફેચ રિક્વેસ્ટ ટ્રિગર કરે છે. ફીલ્ડનો વર્તમાન ટેક્સ્ટ JSON ફોર્મેટમાં મોકલવામાં આવે છે, અને X-Requested-With જેવા કી હેડર્સ એ દર્શાવવા માટે શામેલ કરવામાં આવે છે કે તે AJAX છે, સાથે Laravel ના મૂળ રક્ષણને બાયપાસ કરવા માટે CSRF ટોકન પણ શામેલ કરવામાં આવે છે.

જ્યારે પ્રતિભાવ આવે છે, ત્યારે તે JSON માં રૂપાંતરિત થાય છે અને ગતિશીલ રીતે જનરેટ થાય છે. પરિણામો સાથે એક નાની HTML યાદીઅથવા જ્યારે ક્વેરી કોઈ ડેટા આપતી નથી ત્યારે "કોઈ પરિણામ મળ્યું નથી" જેવો સંદેશ. આ બધું પૃષ્ઠને ફરીથી લોડ કર્યા વિના, વપરાશકર્તા માટે સ્વાભાવિક રીતે.

આ પેટર્નને નાની UX વિગતો સાથે વધુ શુદ્ધ કરી શકાય છે, જેમ કે a ઉમેરીને વિલંબ (ડિબાઉન્સ) કીસ્ટ્રોક વચ્ચે, લોડર પ્રદર્શિત કરો અથવા નેટવર્ક ભૂલોને હેન્ડલ કરો જેથી કંઈક નિષ્ફળ જાય ત્યારે ઇન્ટરફેસ સ્થિર ન દેખાય.

jQuery નો ઉપયોગ કરીને Laravel અને AJAX સાથે લાઇવ શોધ

જોકે આજકાલ ફેચ ખૂબ લોકપ્રિય બન્યું છે, jQuery AJAX ખૂબ જ લોકપ્રિય રહે છે લેગસી પ્રોજેક્ટ્સમાં અથવા એવી ટીમોમાં કે જેમણે પહેલાથી જ તેનો અમલ કર્યો છે. વિચાર બરાબર એ જ છે: વપરાશકર્તા શું ટાઇપ કરે છે તે કેપ્ચર કરો, એક અસુમેળ વિનંતી કરો અને DOM ને રિફ્રેશ કરો.

લાઇવ સર્ચ માટે લારાવેલમાં jQuery સાથેના એક લાક્ષણિક વર્કફ્લોમાં સામાન્ય રીતે આ મૂળભૂત પગલાં શામેલ હોય છે: ચોક્કસ રૂટ વ્યાખ્યાયિત કરો, સમર્પિત નિયંત્રક બનાવો, શોધ ઇનપુટ સાથે બ્લેડ વ્યૂ બનાવો અને છેલ્લે, jQuery કોડ ઉમેરો જે AJAX ટાઇપ કરતી વખતે તેને ટ્રિગર કરે છે.

આ પ્રક્રિયા આ રીતે કાર્ય કરે છે: જ્યારે વપરાશકર્તા ટાઇપ કરવાનું શરૂ કરે છે, jQuery સર્વરને ક્વેરી મોકલે છે શોધ શબ્દમાળા સાથે. Laravel ડેટાબેઝમાં માહિતી ફિલ્ટર કરે છે, મેચિંગ પરિણામો સાથે JSON પરત કરે છે, અને jQuery મેચોને પ્રતિબિંબિત કરવા માટે પૃષ્ઠ પર HTML કન્ટેનરને અપડેટ કરે છે, આ બધું મિલિસેકન્ડમાં.

jQuery નો ઉપયોગ કરવાનો ફાયદો એ છે કે તે AJAX ના વાક્યરચનાનો સારાંશ આપે છે. અને જો તમારી પાસે તમારા પ્રોજેક્ટમાં પહેલેથી જ લાઇબ્રેરી હોય તો તે વાંચવું ખૂબ જ સરળ છે. જો કે, તમે એક વધારાની ડિપેન્ડન્સી ઉમેરી રહ્યા છો જે જો તમે આધુનિક JavaScript અને નેટિવ ફેચ સાથે કામ કરી શકો તો જરૂરી ન પણ હોય.

Alpine.js સાથે ફ્રન્ટએન્ડ પર રીઅલ-ટાઇમ ફિલ્ટરિંગ અને શોધ

જ્યારે પ્રદર્શિત કરવાનો ડેટા પ્રમાણમાં નાનો હોય (ઉદાહરણ તરીકે, ૩૦,૦૦૦ થી ઓછી વસ્તુઓ), જટિલ શોધ સાથે બેકએન્ડ સેટ કરવું હંમેશા યોગ્ય નથી. તે કિસ્સાઓમાં, એક ખૂબ જ અનુકૂળ વિકલ્પ છે Alpine.js વડે સીધા બ્રાઉઝરમાં ફિલ્ટર કરો, વપરાશકર્તા ટાઇપ કરતી વખતે સર્વરને વિનંતીઓ કર્યા વિના.

વિચાર એ છે કે દરેક ઘટક માટે શોધ શબ્દમાળા (ઉદાહરણ તરીકે, નામ, વર્ણન અને શ્રેણી નાના અક્ષરોમાં) પૂર્વ-ગણતરી કરવી, તેને ડેટા-સર્ચ-ટેક્સ્ટ એટ્રિબ્યુટમાં સંગ્રહિત કરવી, અને બાકીનું કામ Alpine.js ને સોંપવું. લખાણ અનુસાર તત્વો બતાવો અથવા છુપાવો શોધ ક્ષેત્રમાં.

Alpine.js ઘટકનું માળખું આના જેવું જ હોઈ શકે છે: ફિલ્ટર આઇટમ્સ

{
search: '',
hasResults: true,
selectedValue: '',
init() {
this.$watch('search', () => this.filterItems());
this.$nextTick(() => this.$refs.searchInput?.focus());
},
filterItems() {
const searchLower = this.search.toLowerCase().trim();
const cards = this.$el.querySelectorAll('.item-card');
let visibleCount = 0;

cards.forEach(card => {
const text = card.dataset.searchText || '';
const isVisible = searchLower === '' || text.includes(searchLower);
card.style.display = isVisible ? '' : 'none';
if (isVisible) visibleCount++;
});

this.hasResults = visibleCount > 0;
},
}

દૃશ્યમાં, દરેક કાર્ડ અથવા ડેટાની હરોળમાં એક વિશેષતા હશે ડેટા-સર્ચ-ટેક્સ્ટ જેમાં પહેલાથી જ નાના અક્ષરોમાં તૈયાર કરેલું લખાણ હોયતેથી, જાવાસ્ક્રિપ્ટમાં ફિલ્ટરને includes() ફંક્શનમાં ઘટાડી દેવામાં આવે છે, જે ટૂંકી સૂચિઓ માટે ખૂબ જ ઝડપી છે:

<input type="search" x-model="search" x-ref="searchInput" placeholder="Buscar..." />
<div>
<div class="item-card" data-search-text="formulario contacto simple">
<h3>Formulario de contacto</h3>
<p>Formulario de contacto simple</p>
</div>
</div>

વધુમાં, તમે ખાલી સ્ટેટ બ્લોક ફક્ત ત્યારે જ પ્રદર્શિત કરી શકો છો જ્યારે વર્તમાન શોધ શબ્દ માટે કોઈ પરિણામો નથી.વપરાશકર્તાને ટેક્સ્ટમાં ફેરફાર કરવા અથવા ફીલ્ડ સાફ કરવા માટે આમંત્રિત કરવા માટે એક બટનનો ઉપયોગ કરવો જે શોધને ખાલી સ્ટ્રિંગ પર રીસેટ કરે છે.

આ અભિગમના સ્પષ્ટ ફાયદા છે: શોધ દરમિયાન કોઈ સર્વર કૉલ્સ નથી.આ ક્રિયાપ્રતિક્રિયા લગભગ તાત્કાલિક છે, અને તર્ક ખૂબ જ સ્થાનિક અને ડીબગ કરવા માટે સરળ રહે છે. તે ઝડપી પસંદગીકારો, આઇટમ પસંદગી મોડલ્સ અથવા લારાવેલ પૃષ્ઠમાં એમ્બેડ કરેલા નાના કેટલોગ માટે યોગ્ય છે.

લારાવેલ સ્કાઉટ: વિશિષ્ટ એન્જિન સાથે પૂર્ણ-ટેક્સ્ટ શોધ

જ્યારે વસ્તુઓ ગંભીર બને છે અને તમને જરૂર હોય છે ઝડપી, સુસંગત અને સ્કેલેબલ પૂર્ણ-ટેક્સ્ટ શોધલારાવેલમાં કુદરતી માર્ગ લારાવેલ સ્કાઉટ છે. સ્કાઉટ એક ઇન્ટિગ્રેશન લેયર છે જે તમને તમારા એલોક્વન્ટ મોડેલ્સને એલ્ગોલિયા, મેઇલિસર્ચ, તમારા પોતાના ડેટાબેઝ, ઇન-મેમરી કલેક્શન અથવા તો ઇલાસ્ટિકસર્ચ જેવા સર્ચ એન્જિન સાથે બાહ્ય નિયંત્રકો દ્વારા સરળતાથી કનેક્ટ કરવાની મંજૂરી આપે છે.

સ્કાઉટ સાથે શરૂઆત કરવા માટે, સામાન્ય બાબત એ છે કે નવો લારાવેલ પ્રોજેક્ટ બનાવો અથવા હાલના પ્રોજેક્ટનો ફરીથી ઉપયોગ કરોતેને લોન્ચ કરવા માટે, ડોકરનો ઉપયોગ કરો (ઉદાહરણ તરીકે, લારાવેલ સેઇલ સાથે) અને પછી કમ્પોઝર સાથે લાઇબ્રેરી ઇન્સ્ટોલ કરો. એકવાર તે થઈ જાય, પછી scout.php રૂપરેખાંકન ફાઇલ પ્રકાશિત કરો અને તમે જે ડ્રાઇવરનો ઉપયોગ કરવા માંગો છો તે અનુસાર પર્યાવરણ ચલોને સમાયોજિત કરો.

એક લાક્ષણિક વર્કફ્લો એ હશે કે સ્કાઉટને કમ્પોઝર સાથે ઇન્સ્ટોલ કરવું, તેનું રૂપરેખાંકન પ્રકાશિત કરવું, અને SCOUT_QUEUE=true સાથે ઇન્ડેક્સિંગ કતાર સક્રિય કરો .env ફાઇલમાં, ખાતરી કરો કે રિસોર્સ-ઇન્ટેન્સિવ ઓપરેશન્સ પૃષ્ઠભૂમિમાં પ્રક્રિયા કરવામાં આવે છે, જે એપ્લિકેશન પ્રતિભાવ સમયને સુધારે છે. વધુમાં, તમારે ખાતરી કરવી જોઈએ કે DB_HOST તમે જે ડેટાબેઝનો ઉપયોગ કરી રહ્યા છો તે તરફ નિર્દેશ કરે છે, જે ખાસ કરીને જો તમે ડોકર કન્ટેનરનો ઉપયોગ કરી રહ્યા હોવ તો મહત્વપૂર્ણ છે.

સ્કાઉટ શોધમાં ભાગ લેવા માટે મોડેલ માટે, તે જરૂરી છે કે શોધયોગ્ય લક્ષણ ઉમેરીને તેને સ્પષ્ટ રીતે શોધી શકાય તેવું તરીકે ચિહ્નિત કરવા માટેઉદાહરણ તરીકે, જો તમારી પાસે ટ્રેન મોડેલ હોય જે શીર્ષક ક્ષેત્ર સાથે ટ્રેનોના કોષ્ટકનું પ્રતિનિધિત્વ કરે છે, તો તમે તેને આ રીતે વ્યાખ્યાયિત કરી શકો છો:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class Train extends Model
{
use Searchable;

protected $fillable = ['title'];

public function searchableAs()
{
return 'trains_index';
}
}

શોધયોગ્ય પદ્ધતિ પરવાનગી આપે છે સર્ચ એન્જિનમાં ઇન્ડેક્સ નામ કસ્ટમાઇઝ કરોમોડેલમાંથી મેળવેલા ડિફોલ્ટ નામનો ઉપયોગ કરવાને બદલે, સ્કાઉટ કાર્યભાર સંભાળે છે. અહીંથી, સ્કાઉટ પસંદ કરેલા ડ્રાઇવરના આધારે, રિમોટ અથવા સ્થાનિક ઇન્ડેક્સ સાથે બનાવટ, અપડેટ અને ડિલીટ કરવાની કામગીરીને સિંક્રનાઇઝ કરવાનું સંચાલન કરે છે.

અલ્ગોલિયા સાથે લારાવેલ સ્કાઉટ: વીજળી-ઝડપી SaaS શોધ

અલ્ગોલિયા એક SaaS સેવા છે જેના પર ધ્યાન કેન્દ્રિત કરવામાં આવે છે મોટા પ્રમાણમાં ડેટા પર ખૂબ જ ઝડપી અને સુસંગત શોધ પ્રદાન કરવા માટેતેમાં અનુક્રમણિકાઓ, સુસંગતતા નિયમો, સમાનાર્થી શબ્દો વગેરેનું સંચાલન કરવા માટે એક વેબ પેનલ છે, અને તે સ્કાઉટ અને સત્તાવાર PHP ક્લાયંટ દ્વારા લારાવેલ સાથે ખૂબ સારી રીતે સંકલિત થાય છે.

સ્કાઉટ સાથે અલ્ગોલિયાનો ઉપયોગ કરવા માટે, તમારે કમ્પોઝર સાથે તેનો PHP ક્લાયંટ ઇન્સ્ટોલ કરવો પડશે, .env ફાઇલ (એપ્લિકેશન ID અને એડમિન API કી) માં તમારા ઓળખપત્રો રજીસ્ટર કરવા પડશે, અને સેટ SCOUT_DRIVER=algolia સ્કાઉટને આ એન્જિનનો ઉપયોગ કરવાનું કહેવા માટે. અલ્ગોલિયા પેનલમાંથી તમે એપ્લિકેશન ID અને વહીવટી કી બંને મેળવી શકો છો.

એકવાર પર્યાવરણ ગોઠવાઈ જાય, પછી તમે પદ્ધતિઓનો ઉપયોગ કરી શકો છો જેમ કે ટ્રેન::શોધ('ટેક્સ્ટ')->પૃષ્ઠ(6) અનુક્રમિત ક્ષેત્રો પર શોધ કરવા માટે સીધા તમારા નિયંત્રકોમાં જાઓ, બ્લેડ વ્યૂમાં પસાર થવા માટે તૈયાર પૃષ્ઠાંકિત ઇલોક્વન્ટ ફોર્મેટમાં પરિણામો પ્રાપ્ત કરો.

ઉદાહરણ તરીકેતમારી પાસે એક નિયંત્રક હોઈ શકે છે ઇન્ડેક્સ જે બધી ટ્રેનોની યાદી આપે છે અથવા જો ટાઇટલસર્ચ પેરામીટર પ્રાપ્ત થાય તો શોધ કરે છે, અને ઇન્ડેક્સમાં નવી ટ્રેનો દાખલ કરવા માટે ક્રિએટ પદ્ધતિ:

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'));
}

public function create(Request $request)
{
$this->validate($request, ['title' => 'required']);
Train::create($request->all());
return back();
}

અનુરૂપ દૃશ્યમાં, તમે ભેગા કરી શકો છો નવી ટ્રેનોની નોંધણી માટેનું ફોર્મ અને બીજું GET ફોર્મ જેમાં ટાઇટલસર્ચ ફીલ્ડ હોય છે જે સબમિટ કર્યા પછી શોધ શરૂ કરે છે. પછી તમારે ફક્ત ટ્રેનોના સંગ્રહમાંથી પુનરાવર્તન કરવાની અને તેમના ફીલ્ડ્સને ટેબલમાં પ્રદર્શિત કરવાની જરૂર છે, જેમાં Laravel દ્વારા જનરેટ કરાયેલ પેજિનેશન લિંક્સનો લાભ લેવામાં આવશે.

મેઇલિસર્ચ, ડેટાબેઝ અને સંગ્રહો સાથે સ્કાઉટ કરો

જો તમે બાહ્ય સેવાઓ ટાળવાનું પસંદ કરો છો, મીલીસર્ચ એક ઓપન સોર્સ સર્ચ એન્જિન છે. જેને તમે સ્થાનિક રીતે અથવા તમારા ઇન્ફ્રાસ્ટ્રક્ચર પર જમાવી શકો છો. સ્કાઉટ એલ્ગોલિયા જેવી જ રીતે મેઇલિસર્ચ સાથે એકીકૃત થાય છે, ફક્ત ડ્રાઇવરને બદલીને અને .env ફાઇલમાં MEILISEARCH_HOST અને MEILISEARCH_KEY ચલોને ઉમેરીને.

તેનો ઉપયોગ કરવા માટે, તમે Meilisearch PHP ક્લાયંટ ઇન્સ્ટોલ કરો, ગોઠવો SCOUT_DRIVER=મેઇલિસર્ચ અને MEILISEARCH_HOST ને ઇન્સ્ટન્સ URL પર પોઇન્ટ કરો (ઉદાહરણ તરીકે, http://127.0.0.1:7700). જો તમારી પાસે પહેલાથી જ અગાઉના રેકોર્ડ્સ હોય, તો તમે તેમને php artisan scout:import "App\Models\Train" આદેશથી ઇન્ડેક્સ કરી શકો છો જેથી એન્જિન તેમને ઉપલબ્ધ કરાવી શકે.

નાના અથવા મધ્યમ એપ્લિકેશનોમાં, તમે આ પણ પસંદ કરી શકો છો સ્કાઉટ ડ્રાઇવર ડેટાબેઝઆ તમારા MySQL અથવા PostgreSQL ડેટાબેઝ પર ફુલ-ટેક્સ્ટ ઇન્ડેક્સ અને LIKE આદેશોનો ઉપયોગ કરે છે. આ કિસ્સામાં, તમારે બાહ્ય સેવાની જરૂર નથી; સ્કાઉટ ડેટાબેઝનો ઉપયોગ તેના સર્ચ એન્જિન તરીકે કરી શકે તે માટે ફક્ત SCOUT_DRIVER=database સેટ કરો.

બીજો રસપ્રદ વિકલ્પ છે ડ્રાઇવર કલેક્શન, જે મેમરીમાં ઇલોક્વન્ટ કલેક્શન પર કામ કરે છેઆ એન્જિન WHERE કલમો અને કલેક્શન ફિલ્ટરિંગનો ઉપયોગ કરીને પરિણામો ફિલ્ટર કરે છે, અને Laravel દ્વારા સપોર્ટેડ કોઈપણ ડેટાબેઝ સાથે સુસંગત છે. તમે તેને `SCOUT_DRIVER=collection` સાથે સક્રિય કરી શકો છો અથવા વધુ ચોક્કસ સેટિંગ્સ માટે Scout રૂપરેખાંકન ફાઇલને સમાયોજિત કરીને સક્રિય કરી શકો છો.

એક્સપ્લોરરનો ઉપયોગ કરીને ઇલાસ્ટિકસર્ચ સાથે એકીકરણ

જો તમારી શોધની જરૂરિયાતોમાં શામેલ હોય તો વિશાળ માત્રામાં ડેટા અને રીઅલ-ટાઇમ વિશ્લેષણ સાથે કામ કરવુંઇલાસ્ટીસર્ચ એક ક્લાસિક છે. લારાવેલ ઇકોસિસ્ટમમાં, તેને સ્કાઉટ સાથે એકીકૃત કરવાની એક આધુનિક રીત એ છે કે એક્સપ્લોરર કંટ્રોલરનો ઉપયોગ કરવો, જે તમારા મોડેલો અને ઇલાસ્ટીસર્ચ ક્લસ્ટર વચ્ચે પુલ તરીકે કામ કરે છે.

આ કરવા માટે, ડોકરનો ઉપયોગ સામાન્ય રીતે સમૃદ્ધ ડોકર-કંપોઝ ફાઇલ સાથે કરવામાં આવે છે, જે લાક્ષણિક સેવાઓ (લારાવેલ, માયએસક્યુએલ, રેડિસ, મેઇલિસર્ચ, વગેરે) ઉપરાંત, ઇલાસ્ટિકસર્ચ અને કિબાના કન્ટેનરપછી તમે કમ્પોઝર દ્વારા jeroen-g/explorer પેકેજ ઇન્સ્ટોલ કરો અને કયા મોડેલોને ઇન્ડેક્સ કરવા જોઈએ તે દર્શાવવા માટે તેની રૂપરેખાંકન ફાઇલ પ્રકાશિત કરો.

config/explorer.php ફાઇલમાં તમે તમારા મોડેલ્સને indexes કી હેઠળ રજીસ્ટર કરી શકો છો, ઉદાહરણ તરીકે ઉમેરીને એપ\મોડેલ્સ\ટ્રેન::ક્લાસવધુમાં, તમે SCOUT_DRIVER=elastic સાથે .env ફાઇલમાં સ્કાઉટ ડ્રાઇવરને elastic માં બદલો જેથી બધું Elasticsearch તરફ નિર્દેશ કરે.

ટ્રેન મોડેલમાં, એક્સપ્લોર કરેલ ઇન્ટરફેસ અમલમાં મૂકવો આવશ્યક છે અને પદ્ધતિને ઓવરરાઇડ કરવી આવશ્યક છે. મેપેબલએએસજે ઇન્ડેક્સમાં મોકલવામાં આવનાર ક્ષેત્રોના નકશાને વ્યાખ્યાયિત કરે છે. એક લઘુત્તમ ઉદાહરણ આ હશે:

use JeroenG\Explorer\Application\Explored;
use Laravel\Scout\Searchable;

class Train extends Model implements Explored
{
use Searchable;

protected $fillable = ['title'];

public function mappableAs(): array
{
return [
'id' => $this->id,
'title' => $this->title,
];
}
}

હવેથી, તમે સમાન સ્કાઉટ ઇન્ટરફેસનો ઉપયોગ કરીને ઇલાસ્ટિકસર્ચ પર શોધ શરૂ કરી શકો છો., ખૂબ જ ઓછા પ્રતિભાવ સમય અને આ એન્જિનની સંપૂર્ણ ક્વેરી પાવરનો લાભ મેળવી રહ્યા છીએ, પરંતુ લારાવેલ ઇકોસિસ્ટમ છોડ્યા વિના.

આ બધા અભિગમો સાથે - ફેચ અથવા jQuery સાથે મૂળભૂત સ્વતઃપૂર્ણથી લઈને, Alpine.js સાથે ફ્રન્ટએન્ડ ફિલ્ટરિંગ સુધી, Laravel Scout અને વિવિધ ડ્રાઇવરો સાથે પૂર્ણ-ટેક્સ્ટ શોધ સુધી - લારાવેલ તમને રીઅલ-ટાઇમ શોધ લાગુ કરવા માટે વિકલ્પોની વિશાળ શ્રેણી આપે છે. તમારા પ્રોજેક્ટના કદ, તમને જરૂરી કામગીરી અને તમે જે માળખાગત સુવિધાઓ જાળવવા તૈયાર છો તેના આધારે તૈયાર કરવામાં આવે છે.