Zarządzanie funkcjami języka Go

Biblioteka zarządzania funkcjami języka Go umożliwia opracowywanie i uwidacznianie funkcji aplikacji na podstawie flag funkcji. Po utworzeniu nowej funkcji wiele aplikacji ma specjalne wymagania, takie jak kiedy funkcja powinna być włączona i pod jakimi warunkami. Ta biblioteka umożliwia zdefiniowanie tych relacji, a także integruje się z typowymi wzorcami kodu języka Go, aby uwidocznić te funkcje.

Flagi funkcji umożliwiają aplikacjom języka Go dynamiczne włączanie lub wyłączanie funkcji. Deweloperzy mogą używać flag funkcji w prostych przypadkach użycia, takich jak instrukcje warunkowe.

Poniżej przedstawiono niektóre korzyści wynikające z używania biblioteki zarządzania funkcjami języka Go:

• Wspólna konwencja zarządzania funkcjami
• Niska bariera wejścia
  • Źródło flagi funkcjonalności usługi Azure App Configuration
• Zarządzanie okresem istnienia flagi funkcji
  • Wartości konfiguracji mogą ulec zmianie w czasie rzeczywistym
• Scenariusze proste i złożone
  • Przełączanie funkcji włączania/wyłączania
  • Dynamiczne ocenianie stanu funkcji na podstawie wywołania do serwera

Biblioteka zarządzania funkcjami języka Go to open source. Aby uzyskać więcej informacji, odwiedź repozytorium GitHub.

Przełączniki funkcji

Flagi funkcji mogą być włączone lub wyłączone. Stan flagi można określić warunkowo za pomocą filtrów funkcji.

Filtry funkcji

Filtry funkcji definiują scenariusz włączania funkcji. Gdy funkcja jest oceniana pod kątem tego, czy jest włączona, czy wyłączona, jej lista filtrów funkcji jest przechodzina do momentu, aż jeden z filtrów zdecyduje, że funkcja powinna zostać włączona. W tym momencie funkcja jest uznawana za włączoną i zatrzymywane jest przeszukiwanie filtrów funkcji. Jeśli żaden filtr funkcji nie wskazuje, że funkcja powinna być włączona, jest uważana za wyłączoną.

Na przykład można zaprojektować filtr funkcji przeglądarki Microsoft Edge. Ten filtr funkcji aktywuje wszystkie dołączone do niego funkcje, o ile żądanie HTTP pochodzi z przeglądarki Microsoft Edge.

Konfiguracja flagi funkcji

Zarządzanie funkcjami w języku Go obsługuje korzystanie z flag funkcji zdefiniowanych w usłudze Azure App Configuration za pomocą wbudowanego dostawcy flag funkcjiazappconfig, a także punkt rozszerzalności poprzez interfejsFeatureFlagProvider w celu korzystania z flag funkcji zdefiniowanych przez innych dostawców.

import (
    "context"
    "log"

    "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
    "github.com/microsoft/Featuremanagement-Go/featuremanagement"
    "github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
)


// ... ...
// Load Azure App Configuration
appConfig, err := azureappconfiguration.Load(ctx, authOptions, options)
if err != nil {
    log.Fatalf("Failed to load configuration: %v", err)
}


// Create feature flag provider
featureFlagProvider, err := azappconfig.NewFeatureFlagProvider(appConfig)
if err != nil {
    log.Fatalf("Error creating feature flag provider: %v", err)
}

// Create feature manager
featureManager, err := featuremanagement.NewFeatureManager(featureFlagProvider, nil)
if err != nil {
    log.Fatalf("Error creating feature manager: %v", err)
}

Deklaracja przełącznika funkcji

W poniższym przykładzie pokazano format używany do konfigurowania flag funkcji w pliku JSON.

{
    "feature_management": {
        "feature_flags": [
            {
                "id": "FeatureT",
                "enabled": true
            },
            {
                "id": "FeatureU",
                "enabled": false
            },
            {
                "id": "FeatureV",
                "enabled": true,
                "conditions": {
                    "client_filters": [
                        {
                            "name": "Microsoft.TimeWindow",
                            "parameters": {
                                "Start": "Wed, 01 May 2019 13:59:59 GMT",
                                "End": "Mon, 01 Jul 2019 00:00:00 GMT"
                            }
                        }
                    ]
                }
            }
        ]
    }
}

Sekcja feature_management dokumentu JSON jest używana zgodnie z konwencją do ładowania ustawień flag funkcji. Obiekty flag funkcji muszą być wymienione w tablicy feature_flags w feature_management sekcji .

W powyższej sekcji przedstawiono trzy różne funkcje. Flaga funkcji ma id właściwości i enabled . To id nazwa używana do identyfikowania i odwołowania się do flagi funkcji. Właściwość enabled określa stan włączonej flagi funkcji. Funkcja jest wyłączona, jeśli opcja 'włączone' jest ustawiona na false. Jeśli enabled jest prawdziwe, stan funkcji zależy od warunków. Jeśli nie ma żadnych warunków, funkcja jest włączona. Jeśli istnieją warunki i są spełnione, funkcja jest włączona. Jeśli istnieją warunki i nie są spełnione, funkcja jest wyłączona. Właściwość conditions deklaruje warunki używane do dynamicznego włączania funkcji. Funkcje definiują filtry funkcji w tablicy client_filters . FeatureV określa filtr funkcji o nazwie Microsoft.TimeWindow. Ten filtr jest przykładem konfigurowalnego filtru funkcji. Możemy zobaczyć na przykładzie, że filtr ma Parameters właściwość. Ta właściwość służy do konfigurowania filtru. W takim przypadku konfigurowane są czasy rozpoczęcia i zakończenia dla funkcji, która ma być aktywna.

Szczegółowy schemat feature_management sekcji można znaleźć tutaj.

Zaawansowane: Użycie dwukropka ":" jest zabronione w nazwach flag funkcji.

Deklaracja włączenia/wyłączenia

Poniższy fragment kodu przedstawia alternatywny sposób definiowania funkcji dla prostych funkcji włączania/wyłączania.

{
    "feature_management": {
        "feature_flags": [
            {
                "id": "FeatureT",
                "enabled": "true"
            },
            {
                "id": "FeatureX",
                "enabled": "false"
            }
        ]
    }
}

Typ wymagania

Właściwość requirement_type flagi funkcji służy do określania, czy filtry powinny stosować Any czy All logiki podczas oceniania stanu funkcji. Jeśli requirement_type nie zostanie określony, wartość domyślna to Any.

• Any oznacza, że tylko jeden filtr musi mieć wartość true, aby funkcja została włączona.
• All oznacza, że każdy filtr musi mieć wartość true, aby funkcja została włączona.

Zmiana requirement_type w All zmienia sposób przechodzenia. Po pierwsze, jeśli nie ma filtrów, funkcja jest wyłączona. Następnie filtry funkcji są przechodzine do momentu, aż jeden z filtrów zdecyduje, że funkcja powinna zostać wyłączona. Jeśli żaden filtr nie wskazuje, że funkcja powinna być wyłączona, jest uważana za włączoną.

{
    "feature_management": {
        "feature_flags": [
            {
                "id": "FeatureW",
                "enabled": "true",
                "conditions": {
                    "requirement_type": "All",
                    "client_filters": [
                        {
                            "name": "Microsoft.TimeWindow",
                            "parameters": {
                                "Start": "Wed, 01 May 2019 13:59:59 GMT",
                                "End": "Mon, 01 Jul 2019 00:00:00 GMT"
                            }
                        },
                        {
                            "name": "Percentage",
                            "parameters": {
                                "Value": "50"
                            }
                        }
                    ]
                }
            },
        ]
    }
}

W powyższym przykładzie FeatureW określa requirement_typeAll, co oznacza, że wszystkie jego filtry muszą mieć wartość true, aby funkcja została włączona. W takim przypadku funkcja jest włączona dla 50% użytkowników w określonym przedziale czasu.

Zużycie

Podstawową formą zarządzania funkcjami jest sprawdzenie, czy flaga funkcji jest włączona, a następnie wykonuje akcje na podstawie wyniku. Sprawdzanie stanu flagi funkcji odbywa się za pomocą metody FeatureManagerIsEnabled.

// Create feature flag provider
featureFlagProvider, err := azappconfig.NewFeatureFlagProvider(appConfig)
if err != nil {
    log.Fatalf("Error creating feature flag provider: %v", err)
}

// Create feature manager
featureManager, err := featuremanagement.NewFeatureManager(featureFlagProvider, nil)
if err != nil {
    log.Fatalf("Error creating feature manager: %v", err)
}

// Check if feature is enabled
enabled, err := featureManager.IsEnabled("FeatureX")
if err != nil {
    log.Printf("Error checking feature: %v", err)
    return
}

if enabled {
    // Do something
}

Implementowanie filtru funkcji

Tworzenie filtru funkcji umożliwia włączanie funkcji na podstawie zdefiniowanych kryteriów. Aby zaimplementować filtr cech, trzeba zaimplementować interfejs FeatureFilter. FeatureFilter ma metodę o nazwie Evaluate. Gdy funkcja jest skojarzona z filtrem, metoda Evaluate jest wywoływana podczas oceny. Jeśli Evaluate zwróci true, funkcja zostanie uznana za włączoną.

type FeatureFilter interface {
	// Name returns the identifier for this filter
	Name() string

	// Evaluate determines whether a feature should be enabled based on the provided contexts
	Evaluate(evalCtx FeatureFilterEvaluationContext, appCtx any) (bool, error)
}

type FeatureFilterEvaluationContext struct {
	// FeatureName is the name of the feature being evaluated
	FeatureName string

	// Parameters contains the filter-specific configuration parameters
	Parameters map[string]any
}

Poniższy fragment kodu przedstawia sposób implementowania dostosowanego filtru funkcji.

type MyCustomFilter struct{}

func (f *MyCustomFilter) Evaluate(ctx context.Context, context *FeatureFilterEvaluationContext) bool {
    // Custom logic to determine if feature should be enabled
    if satisfyCriteria() {
        return true
    }
    return false
}

func (f *MyCustomFilter) Name() string {
    return "MyCustomFilter"
}

Filtry funkcji są rejestrowane poprzez ich podanie podczas tworzenia elementu FeatureManager. Jeśli niestandardowy filtr funkcji wymaga dowolnego kontekstu, można je przekazać za pośrednictwem parametru FeatureFilterEvaluationContext .

// Register custom filters
options := &featuremanagement.Options{
    Filters: []featuremanagement.FeatureFilter{
        &MyCustomFilter{},
    },
}

// Create feature manager with custom filters
featureManager, err := featuremanagement.NewFeatureManager(featureFlagProvider, options)
if err != nil {
    log.Fatalf("Error creating feature manager: %v", err)
}

Filtruj atrybut aliasu

Gdy filtr funkcji jest zarejestrowany dla flagi funkcji, jego nazwa jest używana jako alias domyślny. Ten identyfikator można zastąpić, implementując Name() metodę , która określa nazwę, która ma być używana w konfiguracji podczas odwoływania się do filtru w ramach flagi funkcji.

Brak filtrów funkcji

Jeśli funkcja jest skonfigurowana do włączenia dla określonego filtru funkcji i ten filtr funkcji nie jest zarejestrowany, po ocenie funkcji zostanie zwrócony błąd.

Filtry funkcji wbudowanych

Istnieją dwa filtry funkcji, które są dostarczane z pakietem featuremanagement : TimeWindowFilter, i TargetingFilter.

Każdy z wbudowanych filtrów funkcji ma własne parametry. Oto lista filtrów funkcji wraz z przykładami.

Microsoft.TimeWindow

Ten filtr zapewnia możliwość włączenia funkcji na podstawie przedziału czasu. Jeśli tylko End zostaną określone, funkcja jest traktowana jako włączona do tego czasu. Jeśli zostanie określony tylko Start, funkcja jest uwzględniana we wszystkich punktach po tym czasie.

"client_filters": [
    {
        "name": "Microsoft.TimeWindow",
        "parameters": {
            "Start": "Wed, 01 May 2019 13:59:59 GMT",
            "End": "Mon, 01 Jul 2019 00:00:00 GMT"
        }
    }
]     

Microsoft.Targeting

Ten filtr zapewnia możliwość włączenia funkcji dla odbiorców docelowych. Szczegółowe wyjaśnienie określania wartości docelowej zostało wyjaśnione w poniższej sekcji określania wartości docelowej . Parametry filtru obejmują obiekt opisujący Audience użytkowników, grupy, wykluczonych użytkowników/grup oraz domyślny procent bazy użytkowników, który powinien mieć dostęp do funkcji. Każdy obiekt grupy wymieniony w Groups sekcji musi również określić, jaki procent członków grupy powinien mieć dostęp. Jeśli użytkownik jest określony w Exclusion sekcji , bezpośrednio lub jeśli użytkownik znajduje się w wykluczonej grupie, funkcja jest wyłączona. W przeciwnym razie, jeśli użytkownik jest określony bezpośrednio w sekcji Users, lub jeśli użytkownik jest wliczony w procent uwzględniony w dowolnym wdrożeniu grupy, lub jeśli użytkownik mieści się w domyślnym procencie wdrożenia, ten użytkownik będzie miał włączoną funkcję.

"client_filters": [
    {
        "name": "Microsoft.Targeting",
        "parameters": {
            "Audience": {
                "Users": [
                    "Jeff",
                    "Alicia"
                ],
                "Groups": [
                    {
                        "Name": "Ring0",
                        "RolloutPercentage": 100
                    },
                    {
                        "Name": "Ring1",
                        "RolloutPercentage": 50
                    }
                ],
                "DefaultRolloutPercentage": 20,
                "Exclusion": {
                    "Users": [
                        "Ross"
                    ],
                    "Groups": [
                        "Ring2"
                    ]
                }
            }
        }
    }
]

Celowanie

Określanie wartości docelowej to strategia zarządzania funkcjami, która umożliwia deweloperom stopniowe wdrażanie nowych funkcji w bazie użytkowników. Strategia jest oparta na koncepcji określania celu grupy użytkowników znanej jako docelowa grupa odbiorców. Grupa odbiorców składa się z określonych użytkowników, grup, wykluczonych użytkowników/grup oraz wyznaczonego procentu całej bazy użytkowników. Grupy, które są uwzględnione w grupie odbiorców, można podzielić dalej na wartości procentowe ich całkowitej liczby członków.

W poniższych krokach przedstawiono przykład progresywnego wdrożenia nowej funkcji "Beta":

1. Indywidualni użytkownicy Jeff i Alicia otrzymują dostęp do wersji beta.
2. Inny użytkownik, Mark, prosi o zapisanie się i jest uwzględniony.
3. Dwadzieścia procent grupy znanej jako "Ring1" użytkowników jest uwzględnionych w wersji beta.
4. Liczba użytkowników "Ring1" uwzględnionych w wersji beta wzrosła do 100 procent.
5. Pięć procent bazy użytkowników jest uwzględnionych w wersji beta.
6. Procent wdrożenia jest zwiększony do 100 procent, a funkcja została całkowicie wdrożona.

Ta strategia wdrażania funkcji jest wbudowana w bibliotekę za pomocą dołączonego filtru funkcji Microsoft.Targeting .

Ukierunkowywanie na użytkownika

Filtr selekcji opiera się na kontekście selekcji, aby ocenić, czy funkcja powinna być włączona. Ten kontekst targetowania zawiera informacje, takie jak użytkownik, który jest aktualnie oceniany, oraz grupy, do których należy użytkownik. Kontekst docelowy musi być przekazywany bezpośrednio, gdy IsEnabledWithAppContext jest wywoływany.

// ... ...
// Create targeting context
targetingCtx := featuremanagement.TargetingContext{
    UserID: "test_user",
    Groups: []string{"Ring1"},
}

// Check if feature is enabled for the user
enabled, err := featureManager.IsEnabledWithAppContext("Beta", targetingCtx)
if err != nil {
    log.Printf("Error checking feature: %v", err)
    return
}

if enabled {
    // Feature is enabled for this user
}

Wykluczanie celów targetowania

Podczas definiowania odbiorców użytkownicy i grupy mogą zostać wykluczeni z odbiorców. Wykluczenia są przydatne, gdy funkcja jest wdrażana w grupie użytkowników, ale kilka użytkowników lub grup musi zostać wykluczonych z wdrożenia. Wykluczenie jest definiowane przez dodanie listy użytkowników i grup do Exclusion właściwości odbiorców.

"Audience": {
    "Users": [
        "Jeff",
        "Alicia"
    ],
    "Groups": [
        {
            "Name": "Ring0",
            "RolloutPercentage": 100
        }
    ],
    "DefaultRolloutPercentage": 0,
    "Exclusion": {
        "Users": [
            "Mark"
        ]
    }
}

W powyższym przykładzie funkcja jest włączona dla użytkowników o nazwach Jeff i Alicia. Jest ona również włączona dla użytkowników w grupie o nazwie Ring0. Jeśli jednak użytkownik ma nazwę Mark, funkcja jest wyłączona, niezależnie od tego, czy znajdują się w grupie Ring0 , czy nie. Wykluczenia mają priorytet nad resztą filtru określania wartości docelowej.

Warianty

Po dodaniu nowych funkcji do aplikacji może dojść do czasu, gdy funkcja ma wiele różnych proponowanych opcji projektowania. Typowym rozwiązaniem do podejmowania decyzji o projekcie jest jakaś forma testowania A/B. Testowanie A/B polega na udostępnieniu innej wersji funkcji różnym segmentom bazy użytkowników i wybraniu wersji na podstawie interakcji użytkownika. W tej bibliotece ta funkcja jest włączona przez reprezentowanie różnych konfiguracji funkcji z wariantami.

Warianty przekształcają flagę funkcji w coś więcej niż prostą flagę włącz/wyłącz. Wariant reprezentuje wartość flagi funkcji, która może być ciągiem, liczbą, wartością logiczną, a nawet obiektem konfiguracji. Flaga funkcji, która deklaruje warianty, powinna określać, w jakich okolicznościach należy używać każdego wariantu, co zostało szczegółowo omówione w sekcji Przydzielanie wariantów .

type Variant struct {
	// Name uniquely identifies this variant
	Name string

	// ConfigurationValue holds the value for this variant
	ConfigurationValue any
}

Pobieranie wariantów

Dla każdej cechy, wariant można pobrać za pomocą metody FeatureManagerGetVariant. Przypisanie wariantu zależy od użytkownika obecnie ocenianego, a informacje te są uzyskiwane z przekazanego kontekstu celowania.

targetingCtx := featuremanagement.TargetingContext{
    UserID: "Adam",
}

variant, err := featureManager.GetVariant("TestVariants", targetingCtx)
if err != nil {
    log.Printf("Error getting variant: %v", err)
    return
}

if variant != nil {
    variantConfiguration := variant.Configuration

    // Do something with the resulting variant and its configuration
}

Deklaracja flagi wariantu функции

W porównaniu z flagami funkcji normalnych flagi funkcji wariantu mają jeszcze dwie właściwości: variants i allocation. Właściwość variants jest tablicą zawierającą warianty zdefiniowane dla tej funkcji. Właściwość allocation definiuje sposób przydzielania tych wariantów dla funkcji. Podobnie jak deklarowanie flag funkcji normalnych, można skonfigurować flagi funkcji wariantu w pliku JSON. Oto przykład flagi funkcji wariantowej.

{
    "feature_management": {
        "feature_flags": [
            {
                "id": "MyVariantFeatureFlag",
                "enabled": true,
                "allocation": {
                    "default_when_enabled": "Small",
                    "group": [
                        {
                            "variant": "Big",
                            "groups": [
                                "Ring1"
                            ]
                        }
                    ]
                },
                "variants": [
                    { 
                        "name": "Big"
                    },  
                    { 
                        "name": "Small"
                    } 
                ]
            }
        ]
    }
}

Definiowanie wariantów

Każdy wariant ma dwie właściwości: nazwę i konfigurację. Nazwa jest używana do odwoływania się do określonego wariantu, a konfiguracja jest wartością tego wariantu. Konfigurację można ustawić przy użyciu configuration_value właściwości . configuration_value jest konfiguracją śródliniową, która może być ciągiem, liczbą, wartością logiczną lub obiektem konfiguracji. Jeśli configuration_value nie zostanie określony, zwrócona właściwość wariantu Configuration to nil.

Lista wszystkich możliwych wariantów jest zdefiniowana dla każdej cechy we właściwości variants.

{
    "feature_management": {
        "feature_flags": [
            {
                "id": "MyVariantFeatureFlag",
                "variants": [
                    { 
                        "name": "Big", 
                        "configuration_value": {
                            "Size": 500
                        }
                    },  
                    { 
                        "name": "Small", 
                        "configuration_value": {
                            "Size": 300
                        }
                    } 
                ]
            }
        ]
    }
}

Przydzielanie wariantów

Proces przydzielania wariantów funkcji zależy od allocation właściwości funkcji.

"allocation": { 
    "default_when_enabled": "Small", 
    "default_when_disabled": "Small",  
    "user": [ 
        { 
            "variant": "Big", 
            "users": [ 
                "Marsha" 
            ] 
        } 
    ], 
    "group": [ 
        { 
            "variant": "Big", 
            "groups": [ 
                "Ring1" 
            ] 
        } 
    ],
    "percentile": [ 
        { 
            "variant": "Big", 
            "from": 0, 
            "to": 10 
        } 
    ], 
    "seed": "13973240" 
},
"variants": [
    { 
        "name": "Big", 
        "configuration_value": "500px"
    },  
    { 
        "name": "Small", 
        "configuration_value": "300px"
    } 
]

Ustawienie allocation funkcji ma następujące właściwości:

Jeśli funkcja nie jest włączona, menedżer funkcji przypisuje wariant oznaczony jako default_when_disabled do bieżącego użytkownika, który jest Small w tym przypadku.

Jeśli funkcja jest włączona, menedżer funkcji sprawdza alokacje user, group i percentile w tej kolejności, aby przypisać wariant. W tym konkretnym przykładzie, jeśli oceniany użytkownik ma nazwę Marsha, znajduje się w grupie o nazwie Ring1, lub użytkownik znajduje się między 0 a 10. percentylem, określony wariant zostanie przypisany do użytkownika. W takim przypadku wszyscy przypisani użytkownicy zwróciliby wariant Big. Jeśli żadna z tych alokacji nie pasuje, użytkownikowi przypisywany jest wariant default_when_enabled, który jest Small.

Logika alokacji jest podobna do filtru funkcji Microsoft.Targeting, ale istnieją pewne parametry, które znajdują się w kierowaniu, które nie występują w alokacji i odwrotnie. Wyniki określania wartości docelowej i alokacji nie są powiązane.

Zastępowanie stanu włączonego z wariantem

Można użyć wariantów, aby zastąpić stan włączenia flagi funkcji. Zastępowanie daje wariantom możliwość rozszerzenia oceny flagi funkcjonalności. Podczas wywoływania IsEnabledWithAppContext flagi z wariantami menedżer funkcji sprawdzi, czy wariant przypisany do bieżącego użytkownika jest skonfigurowany do zastąpienia wyniku. Zastępowanie odbywa się przy użyciu opcjonalnej właściwości wariantu status_override. Domyślnie ta właściwość jest ustawiona na None, co oznacza, że wariant nie ma wpływu na to, czy flaga jest uznawana za włączoną, czy wyłączoną. Ustawienie status_override na Enabled pozwala wybranemu wariantowi na przesłonięcie flagi, która ma zostać włączona. Ustawienie status_override na Disabled powoduje przeciwną funkcjonalność, dlatego flaga jest wyłączana po wybraniu wariantu. Nie można nadpisać funkcji, która ma stan enabledfalse.

Jeśli używasz flagi funkcji z wariantami binarnymi, właściwość status_override może być przydatna. Umożliwia to kontynuowanie korzystania z interfejsów API, takich jak IsEnabledaWithAppContext w aplikacji, a jednocześnie korzystanie z nowych funkcji, które towarzyszą wariantom, takich jak alokacja percentylu i seed.

{
    "id": "MyVariantFeatureFlag",
    "enabled": true,
    "allocation": {
        "percentile": [
            {
                "variant": "On",
                "from": 10,
                "to": 20
            }
        ],
        "default_when_enabled":  "Off",
        "seed": "Enhanced-Feature-Group"
    },
    "variants": [
        {
            "name": "On"
        },
        {
            "name": "Off",
            "status_override": "Disabled"
        }
    ]
}

W powyższym przykładzie funkcja jest zawsze włączona. Jeśli bieżący użytkownik znajduje się w obliczonym zakresie percentylu od 10 do 20, zwracany jest wariant On. W przeciwnym razie, zwracany jest wariant Off, a ponieważ status_override jest równy Disabled, funkcja będzie teraz uznana za wyłączoną.

Dalsze kroki

Aby dowiedzieć się, jak używać flag funkcji w aplikacjach, przejdź do następujących szybkich przewodników.

Aby dowiedzieć się, jak używać filtrów funkcji, przejdź do następujących samouczków.