Przykłady nawigacji fasetowej

Ta sekcja rozszerza konfigurację nawigacji fasetowej poprzez przykłady, które demonstrują podstawowe użycie oraz inne scenariusze.

Pola aspektowe są definiowane w indeksie, ale parametry i wyrażenia aspektów są określane w żądaniach zapytań. Jeśli masz indeks z polami obsługującymi aspekty, możesz wypróbować hierarchie aspektów (wersja zapoznawcza), agregacje aspektów (wersja zapoznawcza) i filtry aspektów (wersja zapoznawcza) na istniejących indeksach.

Parametry i składnia faset

W zależności od interfejsu API zapytanie aspektowe jest zwykle tablicą wyrażeń aspektowych, które są stosowane do wyników wyszukiwania. Każde wyrażenie aspektowe zawiera nazwę pola do tworzenia aspektów, opcjonalnie po którym następuje lista par nazwa-wartość, rozdzielana przecinkami.

• zapytanie facet to żądanie zawierające właściwość facetu.
• pole z możliwymi do grupowania wartościami jest definicją pola w indeksie wyszukiwania z przypisaną właściwością facetable.
• count to liczba dopasowań dla każdego aspektu znalezionego w wynikach wyszukiwania.

W poniższej tabeli opisano parametry aspektu używane w przykładach.

count i sort można połączyć w tej samej specyfikacji aspektu, ale nie można ich połączyć z interval lub values.

interval i values nie można połączyć ze sobą.

Aspekty interwałów w godzinie daty są obliczane na podstawie godziny UTC, jeśli timeoffset nie zostanie określony. Na przykład dla "facet=lastRenovationDate,interval:day"parametru granica dnia rozpoczyna się o 00:00:00 UTC.

Podstawowy przykład aspektu

Następujące zapytania dotyczące aspektów działają względem indeksu hotels-sample. Aby wkleić zapytanie JSON, możesz użyć widoku JSON w Eksploratorze wyszukiwania. Aby uzyskać pomoc dotyczącą rozpoczynania pracy, zobacz Dodawanie nawigacji aspektowej do wyników wyszukiwania.

To pierwsze zapytanie pobiera elementy dla kategorii, ocen, tagów i pomieszczeń z wartościami baseRate mieszczącymi się w określonych przedziałach. Zwróć uwagę, że ostatni aspekt znajduje się na podpolu kolekcji Rooms. Aspekty zliczają dokument nadrzędny (Hotele) i nie dokumenty pośrednie (Pokoje), dlatego odpowiedź określa liczbę hoteli , które mają jakiekolwiek pokoje w każdej kategorii cenowej.

POST /indexes/hotels-sample/docs/search?api-version={{api_version}}
{  
  "search": "ocean view",  
  "facets": [ "Category", "Rating", "Tags", "Rooms/BaseRate,values:80|150|220" ],
  "count": true 
}  

W tym drugim przykładzie użyto filtru, aby zawęzić poprzedni wynik zapytania aspektowego po wybraniu przez użytkownika pozycji Ocena 3 i kategorii "Motel".

POST /indexes/hotels-sample/docs/search?api-version={{api_version}}
{  
  "search": "water view",  
  "facets": [ "Tags", "Rooms/BaseRate,values:80|150|220" ],
  "filter": "Rating eq 3 and Category eq 'Motel'",
  "count": true  
} 

Trzeci przykład określa górny limit unikatowych terminów zwracanych w zapytaniu. Wartość domyślna to 10, ale można zwiększyć lub zmniejszyć tę wartość przy użyciu parametru count atrybutu facet. Ten przykład zwraca aspekty dla miasta, ograniczone do 5.

POST /indexes/hotels-sample/docs/search?api-version={{api_version}}
{  
  "search": "view",  
  "facets": [ "Address/City,count:5" ],
  "count": true
} 

W tym przykładzie przedstawiono trzy facety dla "Kategoria", "Tagi" i "Ocena", z przesłonięciem liczby dla "Tagów" i przesłonięciem zakresu dla "Oceny", która w przeciwnym razie jest przechowywana jako liczba zmiennoprzecinkowa typu double w indeksie.

POST https://{{service_name}}.search.windows.net/indexes/hotels-sample/docs/search?api-version={{api_version}}
{
    "search": "*",
    "facets": [ 
        "Category", 
        "Tags,count:5", 
        "Rating,values:1|2|3|4|5"
    ],
    "count": true
}

Dla każdego drzewa nawigacji fasetowej istnieje domyślny limit 10 najwyższych instancji faset znalezionych w wyniku zapytania. To ustawienie domyślne ma sens w przypadku struktur nawigacji, ponieważ przechowuje listę wartości w zarządzanym rozmiarze. Możesz zastąpić wartość domyślną, przypisując wartość do "count". Na przykład "Tags,count:5" zmniejsza liczbę tagów w sekcji Tagi do pięciu pierwszych.

W przypadku wartości liczbowych i DateTime można jawnie ustawiać wartości w polu fasetowym (na przykład facet=Rating,values:1|2|3|4|5), aby oddzielać wyniki na ciągłe zakresy (oparte na wartościach liczbowych lub okresach czasu). Alternatywnie możesz dodać "interwał", jak w pliku facet=Rating,interval:1.

Każdy zakres jest tworzony przy użyciu wartości 0 jako punktu początkowego, wartości z listy jako punktu końcowego, a następnie przycinany z poprzedniego zakresu w celu utworzenia odrębnych interwałów.

Przykład unikatowych wartości

Można sformułować zapytanie, które zwraca liczbę unikalnych wartości dla każdego pola, które można podsumować jako aspekt. W tym przykładzie sformułowane jest puste lub niekwalifikowane zapytanie ("search": "*"), które jest zgodne ze wszystkimi dokumentami, ale ustawiając top wartość zero, uzyskasz tylko liczby bez wyników.

Dla zwięzłości to zapytanie zawiera tylko dwa pola oznaczone jako facetable w indeksie hotels-sample.

POST https://{{service_name}}.search.windows.net/indexes/hotels-sample/docs/search?api-version={{api_version}}
{
    "search": "*",
    "count": true,
    "top": 0,
    "facets": [ 
        "Category", "Address/StateProvince""
    ]
}

Wyniki tego zapytania są następujące:

{
  "@odata.count": 50,
  "@search.facets": {
    "Address/StateProvince": [
      {
        "count": 9,
        "value": "WA"
      },
      {
        "count": 6,
        "value": "CA "
      },
      {
        "count": 4,
        "value": "FL"
      },
      {
        "count": 3,
        "value": "NY"
      },
      {
        "count": 3,
        "value": "OR"
      },
      {
        "count": 3,
        "value": "TX"
      },
      {
        "count": 2,
        "value": "GA"
      },
      {
        "count": 2,
        "value": "MA"
      },
      {
        "count": 2,
        "value": "TN"
      },
      {
        "count": 1,
        "value": "AZ"
      }
    ],
    "Category": [
      {
        "count": 13,
        "value": "Budget"
      },
      {
        "count": 12,
        "value": "Suite"
      },
      {
        "count": 7,
        "value": "Boutique"
      },
      {
        "count": 7,
        "value": "Resort and Spa"
      },
      {
        "count": 6,
        "value": "Extended-Stay"
      },
      {
        "count": 5,
        "value": "Luxury"
      }
    ]
  },
  "value": []
}

Przykład hierarchii aspektów (wersja zapoznawcza)

Korzystając z latest preview REST API lub portalu Azure, można skonfigurować hierarchię aspektów przy użyciu operatorów > i ;.

Kolejność operacji w wyrażeniu aspektowym obejmującym hierarchie aspektów to:

• Operator opcji (przecinek ,) oddzielający parametry aspektu dla pola aspektu, na przykład przecinek w Rooms/BaseRate,values
• Nawiasy, takie jak te otaczające (Rooms/BaseRate,values:50 ; Rooms/Type).
• Operator zagnieżdżania (nawias kątowy >)
• Operator dodawania (średnik ;), pokazany w drugim przykładzie "Tags>(Rooms/BaseRate,values:50 ; Rooms/Type)" w tej sekcji, gdzie dwa podrzędne aspekty są równorzędnymi elementami w obszarze nadrzędnym Tagi.

Należy zauważyć, że nawiasy są przetwarzane przed operacjami zagnieżdżania i dołączania: A > B ; C różni się od A > (B ; C).

Istnieje kilka przykładów dla hierarchii aspektów. Pierwszy przykład to zapytanie, które zwraca tylko kilka dokumentów, co jest przydatne do wyświetlania pełnej odpowiedzi. Facety zliczają dokument nadrzędny (Hotele) i nie dokumenty pośrednie (Pokoje), więc odpowiedź określa liczbę hoteli, które mają jakiekolwiek pokoje w każdej kategorii fasetowej.

POST /indexes/hotels-sample/docs/search?api-version=2026-08-01-preview
{
  "search": "ocean",  
  "facets": ["Address/StateProvince>Address/City", "Tags>Rooms/BaseRate,values:50"],
  "select": "HotelName, Description, Tags, Address/StateProvince, Address/City",
  "count": true 
}

Wyniki tego zapytania są następujące. Oba hotele mają baseny. W przypadku innych tagów tylko jeden hotel zapewnia udogodnienie.

{
  "@odata.count": 2,
  "@search.facets": {
    "Tags": [
      {
        "value": "pool",
        "count": 2,
        "@search.facets": {
          "Rooms/BaseRate": [
            {
              "to": 50,
              "count": 0
            },
            {
              "from": 50,
              "count": 2
            }
          ]
        }
      },
      {
        "value": "air conditioning",
        "count": 1,
        "@search.facets": {
          "Rooms/BaseRate": [
            {
              "to": 50,
              "count": 0
            },
            {
              "from": 50,
              "count": 1
            }
          ]
        }
      },
      {
        "value": "bar",
        "count": 1,
        "@search.facets": {
          "Rooms/BaseRate": [
            {
              "to": 50,
              "count": 0
            },
            {
              "from": 50,
              "count": 1
            }
          ]
        }
      },
      {
        "value": "restaurant",
        "count": 1,
        "@search.facets": {
          "Rooms/BaseRate": [
            {
              "to": 50,
              "count": 0
            },
            {
              "from": 50,
              "count": 1
            }
          ]
        }
      },
      {
        "value": "view",
        "count": 1,
        "@search.facets": {
          "Rooms/BaseRate": [
            {
              "to": 50,
              "count": 0
            },
            {
              "from": 50,
              "count": 1
            }
          ]
        }
      }
    ],
    "Address/StateProvince": [
      {
        "value": "FL",
        "count": 1,
        "@search.facets": {
          "Address/City": [
            {
              "value": "Tampa",
              "count": 1
            }
          ]
        }
      },
      {
        "value": "HI",
        "count": 1,
        "@search.facets": {
          "Address/City": [
            {
              "value": "Honolulu",
              "count": 1
            }
          ]
        }
      }
    ]
  },
  "value": [
    {
      "@search.score": 1.6076145,
      "HotelName": "Ocean Water Resort & Spa",
      "Description": "New Luxury Hotel for the vacation of a lifetime. Bay views from every room, location near the pier, rooftop pool, waterfront dining & more.",
      "Tags": [
        "view",
        "pool",
        "restaurant"
      ],
      "Address": {
        "City": "Tampa",
        "StateProvince": "FL"
      }
    },
    {
      "@search.score": 1.0594962,
      "HotelName": "Windy Ocean Motel",
      "Description": "Oceanfront hotel overlooking the beach features rooms with a private balcony and 2 indoor and outdoor pools. Inspired by the natural beauty of the island, each room includes an original painting of local scenes by the owner. Rooms include a mini fridge, Keurig coffee maker, and flatscreen TV. Various shops and art entertainment are on the boardwalk, just steps away.",
      "Tags": [
        "pool",
        "air conditioning",
        "bar"
      ],
      "Address": {
        "City": "Honolulu",
        "StateProvince": "HI"
      }
    }
  ]
}

Ten drugi przykład rozszerza poprzedni, demonstrując wiele aspektów najwyższego poziomu z wieloma elementami podrzędnymi. Zwróć uwagę, że operator średnika (;) oddziela poszczególne elementy podrzędne.

POST /indexes/hotels-sample/docs/search?api-version=2026-08-01-preview
{  
  "search": "+ocean",  
  "facets": ["Address/StateProvince > Address/City", "Tags > (Rooms/BaseRate,values:50 ; Rooms/Type)"],
  "select": "HotelName, Description, Tags, Address/StateProvince, Address/City",
  "count": true 
}  

Częściowa odpowiedź, skrócona dla zwięzłości, pokazuje tagi z podrzędnymi elementami dla stawki bazowej i typu pomieszczeń. W indeksie przykładowym hoteli oba hotele, które odpowiadają +ocean, mają pokoje każdego typu i basen.

{
  "@odata.count": 2,
  "@search.facets": {
    "Tags": [
      {
        "value": "pool",
        "count": 2,
        "@search.facets": {
          "Rooms/BaseRate": [
            {
              "to": 50,
              "count": 0
            },
            {
              "from": 50,
              "count": 2
            }
          ],
          "Rooms/Type": [
            {
              "value": "Budget Room",
              "count": 2
            },
            {
              "value": "Deluxe Room",
              "count": 2
            },
            {
              "value": "Standard Room",
              "count": 2
            },
            {
              "value": "Suite",
              "count": 2
            }
          ]
        }}]},
  ...
}

W ostatnim przykładzie pokazano reguły pierwszeństwa dla nawiasów wpływających na poziomy zagnieżdżania. Załóżmy, że chcesz zwrócić hierarchię aspektów w tej kolejności.

Address/StateProvince
  Address/City
    Category
    Rating

Aby zwrócić tę hierarchię, utwórz zapytanie, w którym kategoria i ocena są elementami równorzędnymi w obszarze Adres/Miasto.

  { 
    "search": "beach",  
    "facets": [
        "Address/StateProvince > (Address/City > (Category ; Rating))"
        ],
    "select": "HotelName, Description, Tags, Address/StateProvince, Address/City",
    "count": true 
  }

Jeśli usuniesz najbardziej wewnętrzne nawiasy, kategoria i ocena nie są już elementami równorzędnymi, ponieważ reguły pierwszeństwa oznaczają, że > operator jest oceniany przed ;.

  { 
    "search": "beach",  
    "facets": [
        "Address/StateProvince > (Address/City > Category ; Rating)"
        ],
    "select": "HotelName, Description, Tags, Address/StateProvince, Address/City",
    "count": true 
  }

Nadrzędny najwyższego poziomu jest nadal Address/StateProvince, ale teraz Adres/Miasto i Ocena są na tym samym poziomie.

Address/StateProvince
  Rating
  Address/City
    Category

Przykład filtrowania aspektów (wersja zapoznawcza)

Korzystając z interfejsu API REST latest preview lub portalu Azure, można skonfigurować filtry aspektów.

Filtrowanie aspektów umożliwia ograniczenie wartości aspektów zwracanych do tych pasujących do określonego wyrażenia regularnego. Dwa nowe parametry akceptują wyrażenie regularne stosowane do pola aspektu:

• includeTermFilter filtruje wartości aspektów do tych, które są zgodne z wyrażeniem regularnym
• excludeTermFilter filtruje wartości aspektów do tych, które nie są zgodne z wyrażeniem regularnym

Jeśli ciąg fasetowy spełnia oba warunki, excludeTermFilter ma pierwszeństwo, ponieważ zestaw ciągów zasobnika jest najpierw oceniany za pomocą includeTermFilter, a następnie wykluczany z excludeTermFilter.

Zwracane są tylko te wartości aspektów zgodne z wyrażeniem regularnym. Te parametry można połączyć z innymi opcjami aspektów (na przykład count, sort i hierarchicznym aspektowaniem) w polach ciągów.

Ponieważ wyrażenie regularne jest zagnieżdżone w wartości ciągu JSON, należy ująć znaki podwójnego cudzysłowu (") i ukośnika odwrotnego (\). Samo wyrażenie regularne jest rozdzielane ukośnikiem (/). Aby uzyskać więcej informacji na temat wzorców ucieczki, zobacz Wyszukiwanie wyrażeń regularnych.

Poniższy przykład przedstawia sposób ucieczki znaków specjalnych w wyrażeniu regularnym, takim jak ukośnik odwrotny, podwójny cudzysłów lub znaki składni wyrażeń regularnych.

{
    "search": "*", 
    "facets": ["name,includeTermFilter:/EscapeBackslash\\\OrDoubleQuote\\"OrRegexCharacter\\(/"] 
}

Oto przykład filtru faset, który pasuje do hoteli budżetowych i długoterminowych, gdzie klasyfikacja jest podrzędna względem każdej kategorii hotelowej.

POST /indexes/hotels-sample/docs/search?api-version=2026-08-01-preview
{ 
    "search": "*", 
    "facets": ["(Category,includeTermFilter:/(Budget|Extended-Stay)/)>Rating,values:1|2|3|4|5"],
    "select": "HotelName, Category, Rating",
    "count": true 
} 

Poniższy przykład to skrócona odpowiedź (dokumenty hotelowe są pomijane w celu zwięzłości).

{
  "@odata.count": 50,
  "@search.facets": {
    "Category": [
      {
        "value": "Budget",
        "count": 13,
        "@search.facets": {
          "Rating": [
            {
              "to": 1,
              "count": 0
            },
            {
              "from": 1,
              "to": 2,
              "count": 0
            },
            {
              "from": 2,
              "to": 3,
              "count": 4
            },
            {
              "from": 3,
              "to": 4,
              "count": 5
            },
            {
              "from": 4,
              "to": 5,
              "count": 4
            },
            {
              "from": 5,
              "count": 0
            }
          ]
        }
      },
      {
        "value": "Extended-Stay",
        "count": 6,
        "@search.facets": {
          "Rating": [
            {
              "to": 1,
              "count": 0
            },
            {
              "from": 1,
              "to": 2,
              "count": 0
            },
            {
              "from": 2,
              "to": 3,
              "count": 4
            },
            {
              "from": 3,
              "to": 4,
              "count": 1
            },
            {
              "from": 4,
              "to": 5,
              "count": 1
            },
            {
              "from": 5,
              "count": 0
            }
          ]
        }
      }
    ]
  }, 
  "value": [  ALL 50 HOTELS APPEAR HERE ]
}

Przykład agregacji aspektów (wersja zapoznawcza)

Korzystając z najnowszej wersji zapoznawczej API REST lub portalu Azure, można agregować wymiary.

Agregacje aspektów umożliwiają obliczanie metryk z wartości aspektów. Funkcja agregacji działa razem z istniejącymi opcjami fasetowania.

Ustawianie progów dokładności dla agregacji kardynalności

W agregacji kardynalności można ustawić opcję precisionThreshold jako granicę między liczbami, które powinny być zbliżone do dokładnych, oraz tymi, które mogą być mniej dokładne. Wartość maksymalna to 40 000. Wartość domyślna to 3000.

Facetowanie jest wykonywane w pamięci. Zwiększenie precisionThreshold skutkuje większym zużyciem pamięci (wartość precisionThreshold pomnożona przez 8 bajtów).

Przykład: Agregacja sum faceta

Można sumować dowolne pole aspektowe typu danych liczbowych (z wyjątkiem wektorów i współrzędnych geograficznych).

Oto przykład użycia indeksu hotels-sample. Pole Rooms/SleepsCount jest aspektowe i liczbowe, dlatego wybieramy to pole, aby zademonstrować sumę. Jeśli sumujemy to pole, otrzymamy liczbę snu dla całego hotelu. Pamiętaj, że aspekty zliczają dokument nadrzędny (Hotele) i nie dokumenty pośrednie (Pokoje), więc odpowiedź sumuje sleepsCount wszystkich pokoi dla całego hotelu. W tym zapytaniu dodamy filtr, aby zsumować wartość SleepsCount tylko dla jednego hotelu.

POST /indexes/hotels-sample/docs/search?api-version=2026-08-01-preview

{ 
      "search": "*",
      "filter": "HotelId eq '41'",
      "facets": [ "Rooms/SleepsCount, metric: sum"],
      "select": "HotelId, HotelName, Rooms/Type, Rooms/SleepsCount",
      "count": true
}

Odpowiedź dla zapytania może wyglądać podobnie do poniższego przykładu. Windy Ocean Model może pomieścić łącznie 40 gości.

{
  "@odata.count": 1,
  "@search.facets": {
    "Rooms/SleepsCount": [
      {
        "sum": 40.0
      }
    ]
  },
  "value": [
    {
      "@search.score": 1.0,
      "HotelId": "41",
      "HotelName": "Windy Ocean Motel",
      "Rooms": [
        {
          "Type": "Suite",
          "SleepsCount": 4
        },
        {
          "Type": "Deluxe Room",
          "SleepsCount": 2
        },
        {
          "Type": "Budget Room",
          "SleepsCount": 2
        },
        {
          "Type": "Budget Room",
          "SleepsCount": 2
        },
        {
          "Type": "Suite",
          "SleepsCount": 2
        },
        {
          "Type": "Standard Room",
          "SleepsCount": 2
        },
        {
          "Type": "Deluxe Room",
          "SleepsCount": 2
        },
        {
          "Type": "Suite",
          "SleepsCount": 2
        },
        {
          "Type": "Suite",
          "SleepsCount": 4
        },
        {
          "Type": "Standard Room",
          "SleepsCount": 4
        },
        {
          "Type": "Standard Room",
          "SleepsCount": 2
        },
        {
          "Type": "Deluxe Room",
          "SleepsCount": 2
        },
        {
          "Type": "Suite",
          "SleepsCount": 2
        },
        {
          "Type": "Standard Room",
          "SleepsCount": 2
        },
        {
          "Type": "Deluxe Room",
          "SleepsCount": 2
        },
        {
          "Type": "Deluxe Room",
          "SleepsCount": 2
        },
        {
          "Type": "Standard Room",
          "SleepsCount": 2
        }
      ]
    }
  ]
}

Przykład: kompozyt wszystkich agregacji

Oto przykład użycia hipotetycznego indeksu "facets", który pokazuje składnię dla każdej agregacji. Zwróć uwagę, że kardynalność ma dodatkową precisionThreshold opcję (wartość domyślna to 3000) ustawioną na 40 000 w tym przykładzie.

POST https://search-service.search.windows.net/indexes/facets/docs/search?api-version=2026-08-01-preview
Authorization: Bearer {{token}}
Content-Type: application/json

{
    "search": "*",
    "facets": [// field names are named <something>Value in this example 
        "cardinalityValue, metric: cardinality,precisionThreshold: 40000", 
        "sumValue,metric: sum", 
        "avgValue,metric: avg", 
        "minValue,metric: min", 
        "maxValue,metric: max" 
    ] 
}

Odpowiedź dla zapytania może wyglądać podobnie do poniższego przykładu.

{ 
    "@search.facets": { 
        "cardinalityValue": [ 
            { 
                "cardinality": 24000 // Number of distinct values in "cardinalityValue" field 
            } 
        ], 
        "sumValue": [ 
            { 
                "sum": 1200000 // Sum of all values in "sumValue" field 
            } 
        ], 
        "avgValue": [ 
            { 
                "avg": 50 // Average of all values in "avgValue" field 
            } 
        ], 
        "minValue": [ 
            { 
                "min": 1 // Minimum value in "minValue" field 
            } 
        ], 
        "maxValue": [ 
            { 
                "max": 100 // Maximum value in "maxValue" field 
            } 
        ] 
    } 
}

Przykład: określ wartość domyślną, aby zastąpić brakujące wartości

Wszystkie metryki obsługują określanie wartości domyślnej, gdy dokument nie zawiera wartości.

• W przypadku typów nieciągujących (liczbowych, data/godzina, wartość logiczna) ustaw default parametr na określoną wartość: "default: 42" .

• W przypadku typów ciągów ustaw parametr default na ciąg rozdzielany za pomocą pojedynczego apostrofu: "default: 'mystringhere'".

Możesz dodać wartość domyślną, która ma być używana, jeśli dokument zawiera wartość null dla tego pola: "facets": [ "Rooms/SleepsCount, metric: sum, default:2"]. Jeśli pokój ma wartość null dla pola Rooms/SleepsCount, wartość domyślna zastępuje brakującą wartość.

Oto żądanie ilustrujące domyślną specyfikację dla każdego typu pola.

POST https://search-service.search.windows.net/indexes/facets/docs/search?api-version=2026-08-01-preview
Authorization: Bearer {{token}} 
Content-Type: application/json 

{ 
    "search": "*", 
    "facets": [// field names are named <datatype>Value in this example 
        "stringfield, metric: cardinality, default: 'my string goes here'", 
        "doubleField,metric: sum, default: 5.0", 
        "intField,metric: sum, default: 5", 
        "longField,metric: sum, default: 5" 
    ] 
} 

W przypadku pól ciągów wartość domyślna jest rozdzielana przy użyciu znaku pojedynczego cudzysłowu. Aby uciec od znaku, należy poprzedzić go ukośnikiem odwrotnym "\". Wszystkie znaki są prawidłowe wewnątrz znaków ograniczających ciąg. Znak zakończenia nie może być ukośnikiem odwrotnym.

Przykład: wiele metryk w tym samym polu

Jeśli dane bazowe obsługują przypadek użycia, możesz określić wiele metryk w tym samym polu.

POST https://search-service.search.windows.net/indexes/facets/docs/search?api-version=2026-08-01-preview
Authorization: Bearer {{token}} 
Content-Type: application/json 

{ 
    "search": "*", 
    "facets": [ 
        "fieldA, metric: cardinality, precisionThreshold: 40000", 
        "fieldA, metric: sum", 
        "fieldA, metric: avg", 
        "fieldA, metric: min", 
        "fieldA, metric: max" 
    ] 
}

Odpowiedź dla zapytania może wyglądać podobnie do poniższego przykładu.

{ 
    "@search.facets": { 
        "fieldA": [ 
            { 
                "cardinality": 24000 // Number of distinct values in "fieldA" field 
            }, 
            { 
                "sum": 1200000 // Sum of all values in " fieldA " field 
            }, 
            { 
                "avg": 5 // Avg of all values in " fieldA " field
            }, 
            { 
                "min": 0 // Min of all values in " fieldA " field 
            }, 
            { 
                "max": 1200 // Max of all values in " fieldA " field 
            } 
        ] 
    } 
}

Następne kroki

Ponownie zapoznaj się z konfiguracją nawigacji aspektowej dla narzędzi i interfejsów API oraz przejrzyj najlepsze rozwiązania dotyczące pracy z aspektami w kodzie.

Zalecamy C#: Dodaj wyszukiwanie do aplikacji internetowych jako przykład nawigacji fasetowej, zawierających kod dla warstwy prezentacji. Przykład zawiera również filtry, sugestie i autouzupełnianie. Korzysta z języków JavaScript i React dla warstwy prezentacji.