React Native Academy · Leçon

Construire un écran de paramètres persistant

Construire un écran de paramètres persistant est une leçon React Native Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage React Native Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours React Native Academy comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What a Persistent Settings Screen Does

A persistent settings screen lets users configure app preferences — such as dark mode, notification preferences, or language — and have those preferences survive app restarts. The settings are saved to AsyncStorage when changed and loaded back on startup. This is one of the most common patterns in any production React Native app.

Defining the Settings State

Start by defining a TypeScript interface for your settings object and a DEFAULT_SETTINGS constant used when no saved settings exist (first launch). Keeping defaults in a constant makes it easy to fall back safely and to reference the initial shape in type guards and migration logic.

interface Settings {
  darkMode: boolean;
  notificationsEnabled: boolean;
  fontSize: 'small' | 'medium' | 'large';
}

const DEFAULT_SETTINGS: Settings = {
  darkMode: false,
  notificationsEnabled: true,
  fontSize: 'medium',
};

const SETTINGS_KEY = 'app_settings';

Loading Settings on Screen Mount

In a useEffect with an empty dependency array, read the settings from AsyncStorage, parse the JSON, and place the result in component state. Show an ActivityIndicator while loading so the user does not see a momentary flash of default values before the real settings appear.

const [settings, setSettings] = React.useState<Settings>(DEFAULT_SETTINGS);
const [loading, setLoading] = React.useState(true);

useEffect(() => {
  async function loadSettings() {
    const json = await AsyncStorage.getItem(SETTINGS_KEY);
    if (json) {
      setSettings({ ...DEFAULT_SETTINGS, ...JSON.parse(json) });
    }
    setLoading(false);
  }
  loadSettings();
}, []);

Saving Settings When They Change

Create a helper function that merges the new setting into the current settings object and writes the result to AsyncStorage. Call this function from each UI control's change handler so settings are saved immediately after every user interaction. There is no need for a separate 'Save' button for a settings screen.

async function updateSetting<K extends keyof Settings>(key: K, value: Settings[K]) {
  const updated = { ...settings, [key]: value };
  setSettings(updated);
  await AsyncStorage.setItem(SETTINGS_KEY, JSON.stringify(updated));
}

Rendering the Dark Mode Toggle

Use React Native's Switch component for boolean settings. Bind its value prop to the state and call updateSetting in onValueChange. The UI updates instantly via state while AsyncStorage saves in the background, giving a responsive feel without waiting for the write to complete.

<View style={styles.row}>
  <Text style={styles.label}>Dark Mode</Text>
  <Switch
    value={settings.darkMode}
    onValueChange={(value) => updateSetting('darkMode', value)}
    trackColor={{ false: '#ccc', true: '#6200ee' }}
    thumbColor={settings.darkMode ? '#fff' : '#f4f3f4'}
  />
</View>

Rendering a Notification Toggle

Add a second Switch row for the notifications setting following the same pattern. Reusing the same updateSetting helper keeps the code DRY — you only change the key argument to target a different setting. This pattern scales to any number of boolean settings without duplicating save logic.

<View style={styles.row}>
  <Text style={styles.label}>Notifications</Text>
  <Switch
    value={settings.notificationsEnabled}
    onValueChange={(value) => updateSetting('notificationsEnabled', value)}
  />
</View>

Font Size Picker with Pressable Options

For an enum setting like font size, render a row of Pressable buttons, one for each option. Highlight the currently selected option with a different background color. Tapping a button calls updateSetting with the new value. This creates a compact, accessible selection control without a full dropdown.

const fontSizes: Settings['fontSize'][] = ['small', 'medium', 'large'];

<View style={styles.row}>
  <Text style={styles.label}>Font Size</Text>
  <View style={styles.optionRow}>
    {fontSizes.map((size) => (
      <Pressable
        key={size}
        onPress={() => updateSetting('fontSize', size)}
        style={[
          styles.option,
          settings.fontSize === size && styles.optionSelected,
        ]}
      >
        <Text>{size}</Text>
      </Pressable>
    ))}
  </View>
</View>

Applying Settings Globally with Context

For dark mode to affect the entire app, the settings must be shared globally. Load settings at the app root (in App.tsx) and store them in a SettingsContext. Any screen that needs the current theme can read from context instead of loading from AsyncStorage every time. Only the root loads from storage once on startup.

// App.tsx
const [settings, setSettings] = React.useState<Settings>(DEFAULT_SETTINGS);

useEffect(() => {
  loadSettings().then(setSettings);
}, []);

return (
  <SettingsContext.Provider value={{ settings, updateSetting }}>
    <NavigationContainer theme={settings.darkMode ? DarkTheme : DefaultTheme}>
      <AppNavigator />
    </NavigationContainer>
  </SettingsContext.Provider>
);

Reset to Defaults Button

Add a 'Reset to Defaults' button at the bottom of the settings screen. When tapped, it calls AsyncStorage.removeItem to erase the saved settings and resets the local state to DEFAULT_SETTINGS. Confirm the action with an Alert before applying the reset, as it is a potentially destructive operation.

function handleReset() {
  Alert.alert('Reset Settings', 'Restore all settings to their defaults?', [
    { text: 'Cancel', style: 'cancel' },
    {
      text: 'Reset',
      style: 'destructive',
      onPress: async () => {
        await AsyncStorage.removeItem(SETTINGS_KEY);
        setSettings(DEFAULT_SETTINGS);
      },
    },
  ]);
}

Testing Persistence Across Restarts

To verify your settings actually persist, change a setting, close the app completely (not just background it), reopen it, and check that the changed value is shown. In Expo Go you can test this with a force-close. In a development build, shake the device to access the dev menu and reload to simulate a fresh start while keeping AsyncStorage data.

Complete Settings Screen Structure

Here is the full structure of a settings screen combining all the patterns from this lesson. The screen loads settings on mount, renders toggles and pickers that call updateSetting, applies styles that honor the dark mode setting, and includes a reset button at the bottom. This template can be customized for any app's specific preferences.

export default function SettingsScreen() {
  const [settings, setSettings] = React.useState<Settings>(DEFAULT_SETTINGS);
  const [loading, setLoading] = React.useState(true);

  useEffect(() => { loadSettings().then((s) => { setSettings(s); setLoading(false); }); }, []);

  if (loading) return <ActivityIndicator />;

  return (
    <ScrollView style={[styles.container, settings.darkMode && styles.dark]}>
      <SwitchRow label='Dark Mode' value={settings.darkMode}
        onChange={(v) => updateSetting('darkMode', v)} />
      <SwitchRow label='Notifications' value={settings.notificationsEnabled}
        onChange={(v) => updateSetting('notificationsEnabled', v)} />
      <FontSizeRow value={settings.fontSize}
        onChange={(v) => updateSetting('fontSize', v)} />
      <Button title='Reset to Defaults' onPress={handleReset} color='red' />
    </ScrollView>
  );
}

Quick Check

Test your understanding of React Native Mobile Development concepts from this lesson.

Lesson Recap

In this lesson you learned: loading on mount with useEffect restores settings from AsyncStorage before the screen renders, a single updateSetting helper merges changes and writes to AsyncStorage for any settings key, and sharing settings via Context makes preferences like dark mode available throughout the entire app. Next up we explore clearing storage and migration strategies.

Questions Fréquemment Posées

La leçon « Construire un écran de paramètres persistant » est-elle gratuite ?

Oui — le texte complet de « Construire un écran de paramètres persistant » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours React Native Academy, passe à CoddyKit PRO. Le cours React Native Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Construire un écran de paramètres persistant » ?

Créez un écran de paramètres avec des interrupteurs pour les notifications et le mode sombre, conservez chaque réglage dans AsyncStorage et restaurez les préférences au démarrage de l’application. Tu pratiques React Native Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer React Native Academy ?

Aucune expérience préalable n'est requise. React Native Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Construire un écran de paramètres persistant » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon React Native Academy ?

Oui. Chaque leçon React Native Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Lire et écrire avec AsyncStorage
Stocker et analyser des objets JSON
Construire un écran de paramètres persistant
Effacer le stockage et stratégies de migration

← Retour à React Native Academy