Crear conmutadores de características

Los conmutadores de características te permiten habilitar o deshabilitar a distancia la funcionalidad para una selección de usuarios. Crea un nuevo conmutador de características dentro del panel de Braze. Proporciona un nombre y un ID, una audiencia objetivo y un porcentaje de usuarios para los que habilitar esta característica. Luego, utilizando ese mismo ID en el código de tu aplicación o sitio web, puedes ejecutar condicionalmente determinadas partes de tu lógica empresarial. Para saber más sobre los conmutadores de características y cómo puedes utilizarlos en Braze, consulta Acerca de los conmutadores de características.

Requisitos previos

Versión del SDK

Para usar los conmutadores de características, asegúrate de que tus SDK estén actualizados con al menos estas versiones mínimas:

Permisos de Braze

Para gestionar los conmutadores de características en el panel, necesitarás ser administrador o tener los siguientes permisos:

Crear un conmutador de características

Paso 1: Crear un nuevo conmutador de características

Ve a Mensajería > Conmutadores de características y selecciona Crear conmutador de características.

Paso 2: Completar los detalles

En Detalles del conmutador de características, introduce un nombre, ID y descripción para tu conmutador de características.

Paso 2a: Crear propiedades personalizadas

En Propiedades, opcionalmente puedes crear propiedades personalizadas a las que tu aplicación puede acceder a través del SDK de Braze cuando tu característica está habilitada. Puedes asignar un valor de cadena, booleano, imagen, marca de tiempo, JSON o número a cada variable, así como establecer un valor predeterminado.

• ejemplo

En el siguiente ejemplo, el conmutador de características muestra un banner de agotamiento de existencias para una tienda de comercio electrónico usando las propiedades personalizadas listadas:

Nombre de la propiedad	Tipo	Valor
banner_height	number	75
banner_color	string	blue
banner_text	string	Widgets are out of stock until July 1.
dismissible	boolean	false
homepage_icon	image	http://s3.amazonaws.com/[bucket_name]/
account_start	timestamp	2011-01-01T12:00:00Z
footer_settings	JSON	{ "colors": [ "red", "blue", "green" ], "placement": 123 }

Consejo

No hay límite en la cantidad de propiedades que puedes añadir. Sin embargo, las propiedades de un conmutador de características están limitadas a un total de 10.000 caracteres.

Paso 4: Elegir los segmentos objetivo

Antes de desplegar un conmutador de características, necesitas elegir un segmento de usuarios al que dirigirte. Selecciona Añadir regla en tu conmutador recién creado y luego usa los menús desplegables de grupo de filtros y segmento para filtrar usuarios de tu audiencia objetivo. Añade múltiples filtros para refinar aún más tu audiencia.

Paso 5: Configurar el tráfico de despliegue

De forma predeterminada, los conmutadores de características siempre están inactivos, lo que te permite separar la fecha de lanzamiento de tu característica de la activación total de usuarios. Para comenzar tu despliegue, usa la sección Tráfico de despliegue para introducir un porcentaje en el cuadro de texto. Esto elegirá el porcentaje de usuarios aleatorios en tu segmento seleccionado que recibirán esta nueva característica.

Importante

No configures tu tráfico de despliegue a más de 0% hasta que estés listo para que tu nueva característica entre en funcionamiento. Cuando definas inicialmente tu conmutador de características en el panel, deja esta configuración en 0%.

Importante

Para desplegar un conmutador con una sola regla o para una audiencia única, añade tu primera regla con los criterios de segmentación y porcentajes de despliegue seleccionados. Por último, confirma que la regla Todos los demás esté desactivada y guarda tu conmutador.

Implementaciones de conmutadores de características con varias reglas

Usa las implementaciones de conmutadores de características con varias reglas para definir una secuencia de reglas de evaluación de usuarios, lo que permite una segmentación precisa y lanzamientos de características controlados. Este método es ideal para desplegar la misma característica a audiencias diversas.

Orden de evaluación

Las reglas de los conmutadores de características se evalúan de arriba a abajo, en el orden en que aparecen en la lista. Un usuario cumple la primera regla que satisface. Si un usuario no cumple ninguna regla, su elegibilidad se determina por la regla predeterminada “Todos los demás”.

Cualificación de usuarios

• Si un usuario cumple los criterios de la primera regla, es inmediatamente elegible para recibir el conmutador de características.
• Si un usuario no califica para la primera regla, se evalúa con la segunda regla, y así sucesivamente.

La evaluación secuencial continúa hasta que un usuario califica para una regla o llega a la regla “Todos los demás” en la parte inferior de la lista.

Regla “Todos los demás”

La regla “Todos los demás” actúa como predeterminada. Si un usuario no califica para ninguna de las reglas anteriores, su elegibilidad para el conmutador de características se determinará por la configuración del interruptor de la regla “Todos los demás”. Por ejemplo, si la regla “Todos los demás” está desactivada, en el estado predeterminado, un usuario que no cumpla los criterios de ninguna otra regla no recibirá el conmutador de características al iniciar su sesión.

Reordenar reglas

De forma predeterminada, las reglas se ordenan en la secuencia en que se crean, pero puedes reordenarlas arrastrándolas y soltándolas en el panel.

Ejemplos de conmutadores de características con varias reglas

Lanzar gradualmente una página de pago

Supongamos que trabajas para una marca de comercio electrónico y tienes una nueva página de pago que deseas implementar en diferentes regiones geográficas para garantizar la estabilidad. Usando conmutadores de características con varias reglas, puedes configurar lo siguiente:

• Regla 1: Tu Segment de EE. UU. se establece al 100 %.
• Regla 2: Tu Segment se establece al 50 % de tus usuarios brasileños, de modo que no todos reciben el flujo al mismo tiempo.
• Regla 3 (Todos los demás): Para todos los demás usuarios, activa tu regla “Todos los demás” y configúrala al 15 %, de modo que una parte de todos los usuarios pueda pagar con el nuevo flujo.

Alcanzar primero a los testers internos

Supongamos que eres un gestor de producto que quiere asegurarse de que tus testers internos siempre reciban el conmutador de características cuando lanzas un nuevo producto. Puedes añadir tu Segment de testers internos a tu primera regla y configurarla al 100 %, para que tus testers internos sean elegibles durante cada lanzamiento de características.

Utilizar el campo «habilitado» para tus conmutadores de características

Una vez definido tu conmutador de características, configura tu aplicación o sitio web para comprobar si está habilitado para un usuario concreto. Cuando esté habilitado, establecerás alguna acción o harás referencia a las propiedades variables del conmutador de características en función de tu caso de uso. El SDK de Braze proporciona métodos getter para obtener el estado de tu conmutador de características y sus propiedades en tu aplicación.

Los conmutadores de características se actualizan automáticamente al inicio de la sesión, para que puedas mostrar la versión más actualizada de tu característica en el momento del lanzamiento. El SDK almacena en caché estos valores para poder utilizarlos sin conexión.

Nota

Asegúrate de registrar las impresiones del conmutador de características.

Supongamos que vas a lanzar un nuevo tipo de perfil de usuario para tu aplicación. Puedes configurar el ID como expanded_user_profile. A continuación, harías que tu aplicación comprobara si debe mostrar este nuevo perfil de usuario a un usuario concreto. Por ejemplo:

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
6
const featureFlag = braze.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6
let featureFlag = braze.featureFlags.featureFlag(id: "expanded_user_profile")
if featureFlag?.enabled == true {
  print("expanded_user_profile is enabled")
} else {
  print("expanded_user_profile is not enabled")
}

1
2
3
4
5
6
FeatureFlag featureFlag = braze.getFeatureFlag("expanded_user_profile");
if (featureFlag != null && featureFlag.getEnabled()) {
  Log.i(TAG, "expanded_user_profile is enabled");
} else {
  Log.i(TAG, "expanded_user_profile is not enabled");
}

1
2
3
4
5
6
val featureFlag = braze.getFeatureFlag("expanded_user_profile")
if (featureFlag?.enabled == true) {
  Log.i(TAG, "expanded_user_profile is enabled.")
} else {
  Log.i(TAG, "expanded_user_profile is not enabled.")
}

1
2
3
4
5
6
const featureFlag = await Braze.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6
var featureFlag = Appboy.AppboyBinding.GetFeatureFlag("expanded_user_profile");
if (featureFlag != null && featureFlag.Enabled) {
  Console.WriteLine("expanded_user_profile is enabled");
} else {
  Console.WriteLine("expanded_user_profile is not enabled");
}

1
2
3
4
5
6
const featureFlag = await BrazePlugin.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6
BrazeFeatureFlag? featureFlag = await braze.getFeatureFlagByID("expanded_user_profile");
if (featureFlag?.enabled == true) {
  print("expanded_user_profile is enabled");
} else {
  print("expanded_user_profile is not enabled");
}

1
2
3
4
5
6
featureFlag = m.braze.getFeatureFlag("expanded_user_profile")
if featureFlag <> invalid and featureFlag.enabled
  print "expanded_user_profile is enabled"
else
  print "expanded_user_profile is not enabled"
end if

Registro de la impresión de un conmutador de características

Realiza un seguimiento de la impresión de un conmutador de características siempre que un usuario haya tenido la oportunidad de interactuar con tu nueva característica, o cuando podría haber interactuado si la característica está desactivada (en el caso de un grupo de control en una prueba A/B). Las impresiones del conmutador de características solo se registran una vez por sesión.

Normalmente, puedes poner esta línea de código directamente debajo de donde haces referencia a tu conmutador de características en tu aplicación:

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
braze.logFeatureFlagImpression("expanded_user_profile");

1
braze.featureFlags.logFeatureFlagImpression(id: "expanded_user_profile")

1
braze.logFeatureFlagImpression("expanded_user_profile");

1
braze.logFeatureFlagImpression("expanded_user_profile")

1
Braze.logFeatureFlagImpression("expanded_user_profile");

1
Appboy.AppboyBinding.LogFeatureFlagImpression("expanded_user_profile");

1
BrazePlugin.logFeatureFlagImpression("expanded_user_profile");

1
braze.logFeatureFlagImpression("expanded_user_profile");

1
m.Braze.logFeatureFlagImpression("expanded_user_profile");

Acceder a las propiedades

Para acceder a las propiedades de un conmutador de características, utiliza uno de los métodos siguientes, según el tipo que hayas definido en el panel.

Si no existe ninguna propiedad del tipo correspondiente para la clave que proporcionaste, estos métodos devolverán null.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
const featureFlag = braze.getFeatureFlag("expanded_user_profile");

// Returns the String property
const stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
const booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
const numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
const imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a FeatureFlagJsonPropertyValue
const jsonProperty = featureFlag.getJsonProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
let featureFlag: FeatureFlag = braze.featureFlags.featureFlag(id: "expanded_user_profile")

// Returns the string property
let stringProperty: String? = featureFlag.stringProperty(key: "color")

// Returns the boolean property
let booleanProperty: Bool? = featureFlag.boolProperty(key: "expanded")

// Returns the number property as a double
let numberProperty: Double? = featureFlag.numberProperty(key: "height")

// Returns the Unix UTC millisecond timestamp property as an integer
let timestampProperty: Int? = featureFlag.timestampProperty(key: "account_start")

// Returns the image property as a String of the image URL
let imageProperty: String? = featureFlag.imageProperty(key: "homepage_icon")

// Returns the JSON object property as a [String: Any] dictionary
let jsonObjectProperty: [String: Any]? = featureFlag.jsonObjectProperty(key: "footer_settings")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
FeatureFlag featureFlag = braze.getFeatureFlag("expanded_user_profile");

// Returns the String property
String stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
Boolean booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
Number numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as a long
Long timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
String imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a JSONObject
JSONObject jsonObjectProperty = featureFlag.getJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
val featureFlag = braze.getFeatureFlag("expanded_user_profile")

// Returns the String property
val stringProperty: String? = featureFlag.getStringProperty("color")

// Returns the boolean property
val booleanProperty: Boolean? = featureFlag.getBooleanProperty("expanded")

// Returns the number property
val numberProperty: Number? = featureFlag.getNumberProperty("height")

// Returns the Unix UTC millisecond timestamp property as a long
val timestampProperty: Long? = featureFlag.getTimestampProperty("account_start")

// Returns the image property as a String of the image URL
val imageProperty: String?  = featureFlag.getImageProperty("homepage_icon")

// Returns the JSON object property as a JSONObject
val jsonObjectProperty: JSONObject? = featureFlag.getJSONProperty("footer_settings")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Returns the String property
const stringProperty = await Braze.getFeatureFlagStringProperty("expanded_user_profile", "color");

// Returns the boolean property
const booleanProperty = await Braze.getFeatureFlagBooleanProperty("expanded_user_profile", "expanded");

// Returns the number property
const numberProperty = await Braze.getFeatureFlagNumberProperty("expanded_user_profile", "height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = await Braze.getFeatureFlagTimestampProperty("expanded_user_profile", "account_start");

// Returns the image property as a String of the image URL
const imageProperty = await Braze.getFeatureFlagImageProperty("expanded_user_profile", "homepage_icon");

// Returns the JSON object property as an object
const jsonObjectProperty = await Braze.getFeatureFlagJSONProperty("expanded_user_profile", "footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Returns the Feature Flag instance
var featureFlag = Appboy.AppboyBinding.GetFeatureFlag("expanded_user_profile");

// Returns the String property
var stringProperty = featureFlag.GetStringProperty("color");

// Returns the boolean property
var booleanProperty = featureFlag.GetBooleanProperty("expanded");

// Returns the number property as an integer
var integerProperty = featureFlag.GetIntegerProperty("height");

// Returns the number property as a double
var doubleProperty = featureFlag.GetDoubleProperty("height");

// Returns the Unix UTC millisecond timestamp property as a long
var timestampProperty = featureFlag.GetTimestampProperty("account_start");

// Returns the image property as a String of the image URL
var imageProperty = featureFlag.GetImageProperty("homepage_icon");

// Returns the JSON object property as a JSONObject
var jsonObjectProperty = featureFlag.GetJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Returns the String property
const stringProperty = await BrazePlugin.getFeatureFlagStringProperty("expanded_user_profile", "color");

// Returns the boolean property
const booleanProperty = await BrazePlugin.getFeatureFlagBooleanProperty("expanded_user_profile", "expanded");

// Returns the number property
const numberProperty = await BrazePlugin.getFeatureFlagNumberProperty("expanded_user_profile", "height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = await BrazePlugin.getFeatureFlagTimestampProperty("expanded_user_profile", "account_start");

// Returns the image property as a String of the image URL
const imageProperty = await BrazePlugin.getFeatureFlagImageProperty("expanded_user_profile", "homepage_icon");

// Returns the JSON object property as an object
const jsonObjectProperty = await BrazePlugin.getFeatureFlagJSONProperty("expanded_user_profile", "footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
BrazeFeatureFlag featureFlag = await braze.getFeatureFlagByID("expanded_user_profile");

// Returns the String property
var stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
var booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
var numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as an integer
var timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
var imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a Map<String, dynamic> collection
var jsonObjectProperty = featureFlag.getJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
' Returns the String property
color = featureFlag.getStringProperty("color")

' Returns the boolean property
expanded = featureFlag.getBooleanProperty("expanded")

' Returns the number property
height = featureFlag.getNumberProperty("height")

' Returns the Unix UTC millisecond timestamp property
account_start = featureFlag.getTimestampProperty("account_start")

' Returns the image property as a String of the image URL
homepage_icon = featureFlag.getImageProperty("homepage_icon")

' Returns the JSON object property
footer_settings = featureFlag.getJSONProperty("footer_settings")

Obtener una lista de todos los conmutadores de características

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
const features = getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4
let features = braze.featureFlags.featureFlags
for let feature in features {
  print("Feature: \(feature.id)", feature.enabled)
}

1
2
3
4
List<FeatureFlag> features = braze.getAllFeatureFlags();
for (FeatureFlag feature: features) {
  Log.i(TAG, "Feature: ", feature.getId(), feature.getEnabled());
}

1
2
3
4
val featureFlags = braze.getAllFeatureFlags()
featureFlags.forEach { feature ->
  Log.i(TAG, "Feature: ${feature.id} ${feature.enabled}")
}

1
2
3
4
const features = await Braze.getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4
List<FeatureFlag> features = Appboy.AppboyBinding.GetAllFeatureFlags();
foreach (FeatureFlag feature in features) {
  Console.WriteLine("Feature: {0} - enabled: {1}", feature.ID, feature.Enabled);
}

1
2
3
4
const features = await BrazePlugin.getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4
List<BrazeFeatureFlag> featureFlags = await braze.getAllFeatureFlags();
featureFlags.forEach((feature) {
  print("Feature: ${feature.id} ${feature.enabled}");
});

1
2
3
4
features = m.braze.getAllFeatureFlags()
for each feature in features
      print "Feature: " + feature.id + " enabled: " + feature.enabled.toStr()
end for

Actualizar los conmutadores de características

Puedes actualizar los conmutadores de características del usuario actual en mitad de la sesión para obtener los últimos valores de Braze.

Consejo

La actualización se produce automáticamente al iniciar la sesión. Solo es necesario actualizar antes de acciones importantes del usuario, como antes de cargar una página de pago, o si sabes que se hará referencia a un conmutador de características.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
braze.refreshFeatureFlags(() => {
  console.log(`Feature flags have been refreshed.`);
}, () => {
  console.log(`Failed to refresh feature flags.`);
});

1
2
3
4
5
6
7
8
braze.featureFlags.requestRefresh { result in
  switch result {
  case .success(let features):
    print("Feature flags have been refreshed:", features)
  case .failure(let error):
    print("Failed to refresh feature flags:", error)
  }
}

1
braze.refreshFeatureFlags();

1
braze.refreshFeatureFlags()

1
Braze.refreshFeatureFlags();

1
Appboy.AppboyBinding.RefreshFeatureFlags();

1
BrazePlugin.refreshFeatureFlags();

1
braze.refreshFeatureFlags();

1
m.Braze.refreshFeatureFlags()

Escuchar los cambios

Puedes configurar el SDK de Braze para que escuche y actualice tu aplicación cuando el SDK actualice cualquier conmutador de características.

Esto es útil si quieres actualizar tu aplicación cuando un usuario ya no es elegible para una característica. Por ejemplo, establecer algún estado en tu aplicación en función de si una característica está habilitada o no, o de uno de sus valores de propiedad.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku
• react hook

1
2
3
4
5
6
// Register an event listener
const subscriptionId = braze.subscribeToFeatureFlagsUpdates((features) => {
  console.log(`Features were updated`, features);
});
// Unregister this event listener
braze.removeSubscription(subscriptionId);

1
2
3
4
5
6
7
// Create the feature flags subscription
// - You must keep a strong reference to the subscription to keep it active
let subscription = braze.featureFlags.subscribeToUpdates { features in
  print("Feature flags were updated:", features)
}
// Cancel the subscription
subscription.cancel()

1
2
3
4
5
6
braze.subscribeToFeatureFlagsUpdates(event -> {
  Log.i(TAG, "Feature flags were updated.");
  for (FeatureFlag feature: event.getFeatureFlags()) {
    Log.i(TAG, "Feature: ", feature.getId(), feature.getEnabled());
  }
});

1
2
3
4
5
6
braze.subscribeToFeatureFlagsUpdates() { event ->
  Log.i(TAG, "Feature flags were updated.")
  event.featureFlags.forEach { feature ->
    Log.i(TAG, "Feature: ${feature.id}")
  }
}

1
2
3
4
// Register an event listener
Braze.addListener(braze.Events.FEATURE_FLAGS_UPDATED, (featureFlags) => {
  console.log(`featureFlagUpdates`, JSON.stringify(featureFlags));
});

1
2
3
4
// Register an event listener
BrazePlugin.subscribeToFeatureFlagUpdates((featureFlags) => {
    console.log(`featureFlagUpdates`, JSON.stringify(featureFlags));
});

1
2
3
4
5
6
7
8
9
// Create stream subscription
StreamSubscription featureFlagsStreamSubscription;

featureFlagsStreamSubscription = braze.subscribeToFeatureFlags((featureFlags) {
  print("Feature flags were updated");
});

// Cancel stream subscription
featureFlagsStreamSubscription.cancel();

1
2
' Define a function called `onFeatureFlagChanges` to be called when feature flags are refreshed
m.BrazeTask.ObserveField("BrazeFeatureFlags", "onFeatureFlagChanges")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import { useEffect, useState } from "react";
import {
  FeatureFlag,
  getFeatureFlag,
  removeSubscription,
  subscribeToFeatureFlagsUpdates,
} from "@braze/web-sdk";

export const useFeatureFlag = (id: string): FeatureFlag => {
  const [featureFlag, setFeatureFlag] = useState<FeatureFlag>(
    getFeatureFlag(id)
  );

  useEffect(() => {
    const listener = subscribeToFeatureFlagsUpdates(() => {
      setFeatureFlag(getFeatureFlag(id));
    });
    return () => {
      removeSubscription(listener);
    };
  }, [id]);

  return featureFlag;
};

Comprobar la elegibilidad del usuario

Para comprobar a qué conmutadores de características es elegible un usuario en Braze, ve a Audiencia > Buscar usuarios, luego busca y selecciona un usuario.

En la pestaña Elegibilidad de conmutadores de características, puedes filtrar la lista de conmutadores de características elegibles por plataforma, aplicación o dispositivo. También puedes previsualizar la carga útil que se devolverá al usuario seleccionando junto a un conmutador de características.

Ver el registro de cambios

Para ver el registro de cambios de un conmutador de características, abre un conmutador de características y selecciona Registro de cambios.

Aquí puedes revisar cuándo se realizó un cambio, quién lo hizo, a qué categoría pertenece y más.

Segmentación con conmutadores de características

Braze hace un seguimiento automático de los usuarios que tienen habilitado un conmutador de características. Puedes crear un segmento o dirigir mensajería utilizando el filtro Feature Flag. Para más información sobre cómo filtrar por segmentos, consulta Crear un segmento.

Nota

Para evitar segmentos recursivos, no es posible crear un segmento que haga referencia a otros conmutadores de características.

Prácticas recomendadas

No combines los despliegues con Canvas o experimentos

Para evitar que los usuarios se habiliten y deshabiliten desde diferentes puntos de entrada, debes establecer el control deslizante de despliegues en un valor mayor que cero O habilitar el conmutador de características en un Canvas o experimento. Como práctica recomendada, si planeas utilizar un conmutador de características en un Canvas o experimento, mantén el porcentaje de despliegue en cero.

Convenciones de nomenclatura

Para mantener tu código claro y coherente, considera usar el siguiente formato cuando asignes un nombre al ID de tu conmutador de características:

1
BEHAVIOR_PRODUCT_FEATURE

Sustituye lo siguiente:

Este es un ejemplo de conmutador de características donde show es el comportamiento, animation_profile es el producto y driver es la característica:

1
show_animation_profile_driver

Planifica con anticipación

Ve siempre a lo seguro. Al considerar nuevas características que puedan necesitar un interruptor de apagado, es mejor lanzar código nuevo con un conmutador de características y no necesitarlo, que darte cuenta de que se requiere una nueva actualización de la aplicación.

Sé descriptivo

Añade una descripción a tu conmutador de características. Aunque este es un campo opcional en Braze, puede ayudar a responder preguntas que otros puedan tener al explorar los conmutadores de características disponibles.

• Datos de contacto de quién es responsable de la habilitación y el comportamiento de este conmutador
• Cuándo se debe deshabilitar este conmutador
• Enlaces a documentación o notas sobre la nueva característica que controla este conmutador
• Cualquier dependencia o nota sobre cómo usar la característica

Limpia los conmutadores de características antiguos

Todos somos culpables de dejar características activas al 100 % de despliegue más tiempo del necesario.

Para ayudar a mantener tu código (y el panel de Braze) limpio, elimina los conmutadores de características permanentes de tu código base una vez que todos los usuarios se hayan actualizado y ya no necesites la opción de deshabilitar la característica. Esto ayuda a reducir la complejidad de tu entorno de desarrollo, y además mantiene ordenada tu lista de conmutadores de características.