PINQ - Interrogated datasets. Facetterad sökning
Den facetterade sökningen som är inbyggd i webbutiken – internsökning – fungerar snabbt i många avseenden och laddar inte systemet.
- Inbyggd i produkten
- Väldigt snabbt
- Laddar inte webbplatsen
- Är huvuddelen av infoblocks API
- Kräver inte omdesign av webbplatsen
- Omindexeras automatiskt
Klienten presenteras omedelbart med förberedda sökresultat - för valfri kombination av parametrar - fasett. Systemet beräknar fasetter för en produkt i förväg - alla möjliga skärningar av dessa egenskaper i filtret. Dessa färdiga sökuppsättningar skickas sedan ut till kunder.
Varför laddas inte sajten?
I det ögonblick resultatet utfärdas till klienten sker inga beräkningar, eftersom resultatet redan är klart. En aspekt för en ny produkt skapas direkt när den läggs till i försäljningskatalogen. Sökningen indexeras automatiskt på nytt baserat på nya produkter och nya egenskaper.
Fördelar för kunder
Fördelar med facetterad sökning Din kund hittar produkten mycket snabbt och leker lätt med filterinställningarna. Kunden väntar inte utan får resultat direkt. Sökhastigheten beror inte på antalet artiklar i katalogen.
Smart filter 2.0
Din kund hittar produkten mycket snabbt genom att konsekvent begränsa sökfrågan. Och vid varje steg får han omedelbart resultat - en lista över produkter på begäran. Han behöver inte vänta på att hans begäran ska behandlas. Eftersom systemet har beräknat alla möjliga alternativ i förväg och helt enkelt utfärdar blanks. Efterhand visar webbutiken allt färre produkter som resultat. Dessa produkter kommer närmare och närmare köparens begäran.
Interaktivitet och multidimensionalitet
Att välja en produkt för en köpare är som ett spel. Klienten drar parametrar (pris, vikt), byter egenskaper (färg, storlek), ställer in ytterligare villkor (märke, material, smak, etc.) - och systemet omarrangerar omedelbart resultaten. I det här fallet kan det finnas så många anpassningsbara parametrar som du vill - deras antal påverkar inte hastigheten för att generera resultatet.
Bekvämlighet och vänlighet
Med facetterad navigering kan även en oerfaren användare enkelt välja en produkt i butiken. Att manipulera sökverktyg är mycket bekvämt. Dessutom uppmanar systemet köparen med alla parametrar genom vilka han kan välja en produkt. Butiken demonstrerar så att säga för kunden produktens huvudsakliga egenskaper.
Kunden väntar inte på att begäran ska behandlas!
Till exempel, din kund köper en kamera. Inledningsvis anger han bara 3 parametrar i det smarta filtret: pris, märke, storlek. Dess aspekt inkluderar 3 korsningar, det finns många sökresultat, men klienten får dem omedelbart. Klienten ställer in vikten - han behöver en lättviktspryl. Systemet ger honom omedelbart, utan dröjsmål, en mindre varulista. Klienten ställer in skärmstorleken och anger sedan önskad funktionalitet. Framför honom ligger de önskade varorna.
Sökhastighet
Sökhastigheten spelar roll Sökhastigheten påverkar antalet köp som görsIngenting irriterar en kund mer än att ha problem med att hitta produkter på din webbplats. Kunden kommer att åka till andra butiker om han söker för länge. Även om din butik innehåller stort val produkter och många verktyg för att filtrera dem. Kunden kanske inte får resultat från begäran.
Videohandledning: Varför fasetterad sökning snabbar upp ett smart filter avsevärt
Att använda "facetten" påskyndar sökningen i butiken med en storleksordning. I det här fallet beror hastigheten inte på antalet element i katalogen.
Varför går sökningen så långsam?
Att söka efter en produkt i ett skyltfönster kan ta betydligt längre tid än normala sidladdningstider. Speciellt om det finns ett stort antal produkter i butiken och egenskaperna hos dessa produkter. Sök fråga på många sätt skapar det många databasanrop och belastar webbplatsen avsevärt. Om det finns många klienter och förfrågningar saktar sökningen ner avsevärt.
- Smart filterkomponent – 15 gånger snabbare!
- Katalogkomponent – 5 gånger snabbare!
Snabbt även utan en "facett"! Produkten arbetar ständigt med att snabba upp själva katalogkomponenterna. Tjänsten "Site Speed" visar en betydande ökning i hastighet från version till version!
Rekonstruktion
Konstant rekonstruktion av indexering och sökresultat utförs. Algoritmen för innehållsindexering håller på att omarbetas och accelereras. Kvaliteten på presentationen av sökresultaten förbättras - särskilt "brus" minskas. Utvecklarna planerar att visa personlig data för den aktuella klienten i sökresultaten.
För utvecklare: API Transparency
Föregående vy
- Påskynda CIBlockElement::GetList-metoden
- Full integration med smart filter
Full integration med smart filter
Nu, när du gör inställningar i den administrativa delen, för produktegenskaper kan du inte bara ange aktiviteten - om du vill delta eller inte i det smarta filtret. Genom att skicka en egenskap till Smart Filter kan du direkt välja hur du vill visa dem. I vilken form ska fastigheten visas för kunder: knappar, storlekar, skjutreglage, rullgardinslistor, listor med färgval etc.
Visa egendom i Smart Filter
Det smarta filtret ser nu vackrare ut. Utvecklare kan enkelt anpassa och ytterligare anpassa dess utseende.
Vi tog en snabb titt på installationen och grundläggande syntax för PINQ, en port av LINQ till PHP. I den här artikeln kommer vi att titta på hur man använder PINQ för att simulera den facetterade sökfunktionen i MySQL.
I den här artikeln kommer vi inte att täcka alla aspekter av fasetterad sökning. Intresserade kan söka efter lämplig information på Internet.
En typisk facetterad sökning fungerar så här:
- Användaren anger ett nyckelord, eller flera nyckelord, för att söka. Till exempel "router" för att söka efter produkter där ordet "router" förekommer i beskrivningen, nyckelord, kategorinamn, taggar, etc.
- Webbplatsen returnerar en lista över produkter som matchar dessa kriterier.
- Webbplatsen innehåller flera länkar för att anpassa dina söktermer. Till exempel kan det tillåta dig att ange specifika routertillverkare, eller ställa in en prisklass eller andra funktioner.
- Användaren kan fortsätta att ange ytterligare sökkriterier för att erhålla datamängden av intresse.
Facetterad sökning är ganska populär och ett kraftfullt verktyg som kan ses på nästan alla e-handelswebbplatser.
Tyvärr är fasetterad sökning inte inbyggd i MySQL. Så vad ska vi göra om vi fortfarande använder MySQL, men vill ge användaren denna möjlighet?
Med PINQ, som har ett liknande, kraftfullt och enkelt tillvägagångssätt, kan vi uppnå samma beteende som om vi skulle använda andra databasmotorer.
Expanderar demot från första delenObs: all kod från den här delen, och från den första delen, kan hittas i förvaret.
I den här artikeln kommer vi att utöka demon från del 1 med en betydande förbättring i form av facettsökning.
Låt oss börja med index.php och lägga till följande rader till det:
$app->get("demo2", function () använd ($app) ( global $demo; $test2 = new pinqDemo\Demo($app); return $test2->test2($app, $demo->test1 ($app)); )); $app->get("demo2/facet/(nyckel)/(värde)", funktion ($key, $value) use ($app) ( global $demo; $test3 = new pinqDemo\Demo($app); return $test3->test3($app, $demo->test1($app), $key, $value); ));
Den första rutten tar oss till en sida där vi kan se alla poster som matchar sökningen nyckelord. För att göra exemplet enkelt väljer vi alla böcker från tabellen book_book. Den kommer också att visa den resulterande datamängden och en uppsättning länkar för att ange sökkriterierna.
I verkliga applikationer, efter att ha klickat på sådana länkar, kommer alla facettfilter att anpassa sig till gränsvärdena för den resulterande datamängden. Användaren kommer alltså att sekventiellt kunna lägga till nya sökvillkor, till exempel först välja en tillverkare, sedan ange ett prisintervall osv.
Men i det här exemplet kommer vi inte att implementera detta beteende - alla filter kommer att återspegla gränsvärdena för den ursprungliga datamängden. Detta är den första begränsningen och den första kandidaten för förbättringar i vår demo.
Som du kan se i koden ovan finns de faktiska funktionerna i en annan fil som heter pinqDemo.php. Låt oss ta en titt på motsvarande kod som tillhandahåller den facetterade sökfunktionen.
AspektklassDet första steget är att skapa en klass som representerar en aspekt. I allmänhet bör en aspekt innehålla flera egenskaper:
- Datan den arbetar på ($data)
- Nyckeln med vilken grupperingen utförs ($key)
- Nyckeltyp ($type). Kan vara något av följande:
- ange hela strängen för en exakt matchning
- ange en del av strängen (vanligtvis den första) för att söka efter mönster
- ange ett värdeintervall, för gruppering efter intervall
- om nyckeltypen är ett värdeintervall måste du definiera ett värdesteg för att bestämma intervallets nedre och övre gränser; eller om typen är en del av en sträng måste du ange hur många första bokstäver som ska användas för gruppering ($range)
Gruppering är den mest kritiska delen av aspekten. All aggregerad information som en aspekt kan returnera beror på grupperingskriterierna. Vanligtvis är de mest använda sökkriterierna "Full String", "Part of String" eller "Range of Values".
Namnutrymme classFacet ( använd Pinq\ITraversable, Pinq\Traversable; class Facet ( public $data; // Originaldatauppsättning offentlig $nyckel; // fält för att gruppera offentlig $type; // F: hela raden; S: startsträngar ; R: range; public $range; // spelar bara en roll om $type != F ... public function getFacet() ( $filter = ""; if ($this->typ == "F") / / hela raden ( ... ) elseif ($this->typ == "S") // början av raden ( ... ) elseif ($this->typ == "R") // värdeintervall ( $ filter = $this->data ->groupBy(function($row) ( return floor($row[$this->key] / $this->range) * $this->range; )) -> select(funktion (ITraversable $data) (retur ["key" => $data->last()[$this->key], "count" => $data->count()]; )); ) returnera $filter;)))
Huvudfunktionen för denna klass är att returnera en filtrerad datauppsättning baserat på den ursprungliga datauppsättningen och aspektegenskaper. Av koden är det tydligt att för olika typer av konton de använder olika sätt gruppera data. I koden ovan visade vi hur koden kan se ut om vi grupperar data efter ett värdeintervall i steg specificerade i $range .
Ställa in aspekter och visa källdataPublic function test2($app, $data) ( $facet = $this->getFacet($data); return $app["twig"]->render("demo2.html.twig", array("facet" = > $facet, "data" => $data)); ) privat funktion getFacet($originalData) ( $facet = array(); $data = \Pinq\Traversable::from($originalData); // 3 skapelseexempel olika aspektobjekt, och returnera aspekterna $filter1 = new \classFacet\Facet($data, "author", "F"); $filter2 = new \classFacet\Facet($data, "title", "S", 6 ); $filter3 = new \classFacet\Facet($data, "price", "R", 10); $facet[$filter1->key] = $filter1->getFacet(); $facet[$filter2-> key ] = $filter2->getFacet(); $facet[$filter3->key] = $filter3->getFacet(); return $facet; )
I metoden getFacet() gör vi följande:
- Konvertera originaldata till ett Pinq\Traversable-objekt för vidare bearbetning
- Vi skapar tre aspekter. Aspekten 'författare' kommer att grupperas efter författarefältet och implementera gruppering efter hela raden; aspekt 'titel' - efter titelfältet med gruppering efter del av raden (med de första 6 tecknen); aspekt "pris" - efter prisfältet med gruppering efter intervall (i steg om 10)
- Slutligen extraherar vi aspekterna och returnerar dem till test2-funktionen så att de kan matas ut till mallen för visning
I de flesta fall kommer filter att visas som en rad och leder dig till att se det filtrerade resultatet.
Vi har redan skapat en rutt ("demo2/facet/(nyckel)/(värde)") för att visa fasetterade sökresultat och filtrera länkar.
Rutten tar två parametrar, beroende på nyckeln som filtreras efter och värdet för den nyckeln. Test3-funktionen som är bunden till denna rutt visas nedan:
Public function test3($app, $originalData, $key, $value) ($data = \Pinq\Traversable::from($originalData); $facet = $this->getFacet($data); $filter = null; if ($key == "författare") ( $filter = $data ->where(function($row) use ($value) (return $row["author"] == $value;)) ->orderByAscending( function($row) använd ($key) ( return $row["price"]; )) ; ) elseif ($key == "price") ( ... ) else //$key== title ( .. . ) return $app["twig"]->render("demo2.html.twig", array("facet" => $facet, "data" => $filter)); )
I grund och botten, beroende på nyckeln, tillämpar vi filtrering (en anonym funktion i where-satsen) enligt det godkända värdet och får följande uppsättning filtrerade data. Vi kan också ställa in ordningen för datafiltrering.
Slutligen visar vi rådata (tillsammans med filter) i mallen. Den här rutten använder samma mönster som vi använde i "demo2".
Sökruta
- (% för k, v i fasett %)
- ((k|versal))
- ((vv.count))((vv.key)) (%endfor%)
- (% för vv i v %)
Vi måste komma ihåg att de aspekter som genereras av vår applikation är kapslade arrayer. På den första nivån är detta en samling av alla aspekter, och i vårt fall finns det tre av dem (för författare, titel, pris, respektive).
Varje aspekt har en nyckel-värde-array, så vi kan iterera över den med vanliga metoder.
Lägg märke till hur vi bygger webbadresserna för våra länkar. Vi använder både den yttre slingtangenten (k) och den inre slingtangenten (vv.key) som parametrar för rutten ("demo2/facet/(nyckel)/(värde)"). Storleken på arrayerna (vv.count) används för visning i mallen.
Den första bilden visar den ursprungliga datamängden, och den andra bilden filtreras efter prisintervall från $0 till $10, och sorteras efter författare.
Bra, vi kunde simulera fasetterad sökning i vår applikation!
Innan vi avslutar den här artikeln måste vi ta en sista titt på vårt exempel och bestämma vad som kan förbättras och vilka begränsningar vi har.
Möjliga förbättringarI allmänhet är detta ett mycket grundläggande exempel. Vi har precis gått igenom den grundläggande syntaxen och begreppen och implementerat dem som ett fungerande exempel. Som tidigare nämnts har vi flera områden som skulle kunna förbättras för större flexibilitet.
Vi måste implementera "överlägg" sökkriterier, eftersom det aktuella exemplet begränsar oss till möjligheten att tillämpa sökfiltrering endast på den ursprungliga datamängden; vi kan inte tillämpa facetterad sökning på ett redan filtrerat resultat. Det här är den största förbättringen jag kan tänka mig.
RestriktionerFacettsökningen som implementeras i den här artikeln har allvarliga begränsningar (som även kan gälla andra aspektersökningsimplementeringar):
Vi hämtar data från MySQL varje gång
Denna applikation använder Silex-ramverket. Liksom alla enstaka ingångspunkter som Silex, Symfony, Laravel, anropas dess index.php (eller app.php) fil varje gång en rutt analyseras och kontrollerfunktioner exekveras.
Om du tittar på koden i vår index.php kommer du att märka att följande kodrad:
$demo = ny pinqDemo\Demo($app);
anropas varje gång applikationssidan renderas, vilket innebär att följande kodrader exekveras varje gång:
Klassdemo ( privat $books = ""; offentlig funktion __construct($app) ( $sql = "välj * från book_book order by id"; $this->books = $app["db"]->fetchAll($sql );)
Blir det bättre om vi inte använder ett ramverk? Tja, trots att det inte är en bra idé att utveckla applikationer utan ramverk kan jag säga att vi kommer att stöta på samma problem: data (och tillstånd) sparas inte mellan olika HTTP-förfrågningar. Detta är en grundläggande egenskap hos HTTP. Detta kan undvikas genom att använda cachningsmekanismer.
Vi sparade flera SQL-frågor genom att använda aspekter. Istället för att skicka en urvalsfråga för att hämta data, och tre grupp för frågor med motsvarande where-klausuler, körde vi bara en where-fråga och använde PINQ för att få den aggregerade informationen.
SlutsatsI den här delen implementerade vi möjligheten att facettersökning i en samling böcker. Detta är som sagt bara ett litet exempel, som har utrymme för förbättringar, och som har ett antal begränsningar.
( "query": ( "och": [ ( "terms": ("land": ["be", "fr")) ), ( "terms": ("category": ["böcker", "filmer") " "]) ] ) )
För räknare kan vi använda inbyggda aggregationer från Elasticsearch. Var och en av de två aspekterna lagras som ett enda fält i indexet, så vi kan använda aggregering av termer i vart och ett av dessa fält. Aggregeringen returnerar en räknare för värdet på detta fält.
( "query": ( "och": [ ( "terms": ("land": ["be", "fr")) ), ( "terms": ("category": ["böcker", "filmer") " "]) ) ]), "aggregations": ( "länder": ( "terms": ("fält": "land")), "kategorier": ( "termer": ("fält": "kategori" ) ) ) )
Om du skulle köra den här frågan kommer du att märka att räknarna är inaktiverade. De två ovalda länderna, Portugal och Brasilien, har en räknare på 0. Även om det finns faktiska resultat om vi vill välja dem (på grund av ORinner edge). Detta händer eftersom Elasticsearch som standard utför sina aggregationer på resultatuppsättningen. Det betyder att om du väljer Frankrike kommer det andra landets filter att ha en poäng på 0 eftersom resultatuppsättningen bara innehåller objekt från Frankrike.
För att fixa detta måste vi säga till Elasticsearch att utföra aggregeringen på hela datamängden och ignorera frågan. Vi kan göra detta genom att definiera våra kluster som globala.
( "query": ( "och": [ ( "terms": ("land": ["be", "fr")) ), ( "terms": ("category": ["böcker", "filmer") " "]) ) ]), "aggregations": ( "all_products": ( "global": (), "aggregations": ( "countries": ( "terms": ("fält": "land")), " kategorier": ( "termer": ("fält": "kategori") ) ) ) ) )
Om vi bara gjorde detta skulle våra räknare alltid vara desamma eftersom de alltid skulle räkna med hela datamängden, oavsett våra filter. Våra enheter måste bli lite mer komplexa, för att detta ska fungera måste vi lägga till filter till dem. Varje aggregering måste förlita sig på en datamängd med alla filter utom sina egna. Således räknas aggregeringen per konto i Frankrike på datamängden med kategorifiltret tillämpat, men inte landsfiltret:
( "query": ( "och": [ ( "terms": ("land": ["be", "fr")) ), ( "terms": ("category": ["böcker", "filmer") " "]) ) ]), "aggregations": ( "all_products": ( "global": (), "aggregations": ( "countries": ( "filter": ( "and": [ ( "terms": ( "category": ["böcker","filmer") ) ] ), "aggregations": ( "filtered_countries": ( "terms": ("fält": "land") ) ), "categories": ( "filter": ( "och": [ ( "terms": ("land": ["be","fr")) ]), "aggregations": ( "filtered_categories": ( "terms": ( "fält": "kategori") ) ) ) ) ) ) )
( "tog": 153, "timed_out": false, "_shards": ( "total": 5, "successful": 5, "failed": 0), "träffar": ( "total": 3, "max_score ": 0, "träffar": ["..."]), "aggregations": ( "alla_produkter": ( "doc_count": 21, "filtrerade kategorier": ( "doc_count": 13, "categories": ( "doc_count_error_upper_bound": 0, "sum_other_doc_count": 0, "buckets": [ ( "key": "movies", "doc_count": 6 ), ( "key": "music", "doc_count": 4 ), ( "key": "books", "doc_count": 3 ) ] ) ), "filtred_countries": ( "doc_count": 15, "countries": ( "doc_count_error_upper_bound": 0, "sum_other_doc_count": 0, "buckets": [ ( "key": "fr", "doc_count": 6 ), ( "key": "br", "doc_count": 4 ), ( "key": "be", "doc_count": 3 ), ( "key": "pt", "doc_count": 2 ) ] ) ) ) ) )
Yii2 ramverk $terms = QueryHelper::terms("categories.name" , "min kategori" ); $nested = QueryHelper:: kapslad ("string_facet" , QueryHelper:: filter ([ QueryHelper:: term ("string_facet.facet_name" , [ "value" => $id , "boost" => 1 ] ), QueryHelper:: term ("string_facet.facet_value", [ "value" => $värde, "boost" => 1 ] ), ] ) ); $filter = QueryHelper::should ($nested) ;I dagens lektion kommer vi att försöka återskapa en imitation av facetterad sökning med hjälp av Javascript. Jag antar att du redan vet vad facetterad sökning är om du läser den här handledningen, annars googla den eller kolla in Amazon eller min Demo.
Först behöver vi biblioteket github.com/eikes/facetedsearch. Ladda ner den och anslut filen facetedsearch.js till vårt projekt. Vi kommer också att behöva biblioteken jQuery och Underscore.
Ansvarsfriskrivning: Jag förstår att JQ inte längre är en kaka, men jag använder det som bekant syntaktisk socker, du kan skriva om det för bibliotek som är mer bekanta för dig eller i vanilj JS.
Så låt oss först göra en enkel markering med anslutna beroenden:
Dokument // Här kommer vi att visa facettfilter // Och här kommer våra element att vara
Nu måste vi beskriva inställningarna för vår applikation och skapa en mall för att visa arrayelement som vi kommer att sortera med hjälp av fasetter:
$(function())( var item_template = // Beskriv mallen "" + " 
Tja, skapa faktiskt en JSON-array själv med element som ska visas i vår facetterade sökning i JS:
Var items = [ ( "firstname": "Mary", "efternamn": "Smith", "imageURL": "http://lorempixel.com/150/150/cats/2", "description": "Sed Ea Amet. Stet Voluptua. Nonumy Magna Takimata ", "category": "Mouse", "language": ["Smalltalk", "XSLT"], "continent": "Africa"), ( "firstname": "Patricia ", "lastname": "Johnson", "imageURL": "http://lorempixel.com/150/150/cats/3", "description": "Ut Takimata Sit Aliquyam Labore Aliquyam Sit Sit Lorem Amet. Ipsum Rebum ." , "category": "Lion", "continent": "Nordamerika", ... ];
Jag skulle lägga den här arrayen i en separat JS-fil som skulle genereras dynamiskt, till exempel från en databas.
Det är allt, vi får en facetterad sökning i JavaScript och kan anpassa den. Därefter tillhandahåller jag översatt dokumentation av biblioteket, där du kan se de triggers du behöver.
DokumentationsfunktionerTvå funktioner exporteras till jQuery-namnområdet.
facetelize Används för att initiera en fasetterad sökning med de givna inställningarna.
facetUpdate Kan användas om du vill ändra facettsökningsstatus externt.
Objektinställningarobjekt: En uppsättning artiklar som kommer att filtreras och sorteras under processen.
facetter: Ett objekt vars nycklar motsvarar elementnycklar och värden är rubriken för den facetten. Objekt kommer att filtreras baserat på vilket värde de har för dessa nycklar.
orderByOptions: Liknar fasetter, förutom att dessa nyckel-värdepar endast används för sortering. När RANDOM-tangenten är aktiverad kan resultaten slumpas.
facetSelector: Detta är en väljare som används för att hitta en DOM-nod från vilken facettfilter kan väljas.
resultSelector: Detta är en väljare som används för att hitta DOM-noden där resultaten visas.
resultTemplate: En sträng som används av mallmotorn Underscore för att rendera varje element från objektmatrisen. Följande attribut läggs till i varje element, som också kan användas i mallen: batchItemNr, batchItemCount och totalItemCount.
state: Detta objekt lagrar de aktuella filtren, sorterar: currentResult och andra. Du kan tillhandahålla en orderBy-sträng eller ett filterobjekt för att förinställa dem.
enablePagination: Boolean för att aktivera paginering och knappen "ladda in mer" är som standard true .
pagineringCount: Om paginering är aktiverat, ställer in antalet element per sida, standard är 50.
facetSortOption: Använd den här funktionen för att ändra ordningen på facettelement. Tar ett objekt vars nycklar motsvarar fasettnamn och värden till en uppsättning fasettvärden, som kan ordnas i den ordning du vill att de ska vara. Det här exemplet kommer att sortera kontinenterna i en annan ordning och lägga till objekt som inte ingår i arrayen i alfabetisk ordning:
FacetSortOption: ("kontinent": ["Nordamerika", "Sydamerika"))
Det finns några fler mallar, ta en titt källa facetedsearch.js för att se alla tillgängliga mallalternativ.
evenemangDu kan binda till vissa händelser som ska skicka meddelanden när vissa åtgärder inträffade. För att göra detta använder vi händelsesystemet jquery:
facetuicreated: Du kan binda den här funktionen till settings.facetSelector DOM-elementet som ska meddelas när användargränssnittet har skapats.
facetedsearchresultupdate: Du kan binda den här funktionen till settings.resultSelector DOM-elementet för att meddelas om uppdateringsresultaten.
facetedsearchfacetclick: Denna händelse utlöses när en facett klickas och avfyras på settings.facetSelector-elementet. Som får facett-id som argument.
facetedsearchorderby: Denna händelse utlöses när sorteringselementet klickas på elementet settings.facetSelector. Den tar ID-ordern som ett argument.
$(settings.resultSelector).bind("facetedsearchresultupdate", function())( // gör något, kanske ));
Moderna människor försöker lägga mindre och mindre tid på shopping. Långsamma produktkataloger driver bort kunder, butiken tappar kunder och en del av sin vinst. Gör din webbutik mer attraktiv med facettteknik Facet – d.v.s. fördefinierad. Sök. Skapa facetterade index och påskynda sökningen efter produkter och hela katalogens arbete avsevärt.
Obs: Den facetterade sökmekanismen är tillgänglig från version 15.0.1 av informationsblocksmodulen och är integrerad med komponenten En komponent är en programkod designad i ett visuellt skal som utför en specifik funktion av en modul för att visa data i det offentliga del. Vi kan infoga detta kodblock på webbsidor utan att skriva någon kod direkt. Smart filter Komponenten förbereder ett filter för att välja från ett informationsblock och visar ett filterformulär för att filtrera element. Komponenten måste vara ansluten före komponenten för att visa katalogelement, annars kommer listan med element inte att filtreras. Komponenten är standard, ingår i moduldistributionen och innehåller tre mallar: .default , visual_horizontal och visual_vertical . (De två sista mallarna stöds inte, de finns kvar för att bibehålla kompatibiliteten.)
I den visuella redigeraren är komponenten placerad längs vägen Innehåll > Katalog > Smart filter.
Komponenten tillhör modulen Informationsblock.
| Låt oss titta på ett exempel: Vi går till webbutiken och väljer i filtret att vi behöver en röd T-shirt:
|
Låt oss skapa fasetterade index i några enkla steg:
Facetterade index återskapas automatiskt eller så måste du återskapa dem manuellt, beroende på de åtgärder som utförs:
|
Facetterad sökning förbättrar produktkatalogens prestanda. För att använda den behöver du:
Publikationer om ämnet
|
