One place for hosting & domains

      Comment utiliser le routage avec React Navigation dans React Native


      Introduction

      React Navigation est une bibliothèque populaire pour le routage et la navigation dans une application React Native.

      Cette bibliothèque aide à résoudre le problème de la navigation entre plusieurs écrans et du partage des données entre eux.

      À la fin de ce tutoriel, vous disposerez d’un réseau social rudimentaire. Il affichera le nombre de connexions dont dispose un utilisateur et fournira un moyen de se connecter avec des amis supplémentaires. Vous utiliserez cet exemple d’application pour découvrir comment naviguer dans les écrans d’applications mobiles en utilisant react-navigation.

      Conditions préalables

      Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

      Remarque : Si vous avez travaillé avec react-navigation auparavant, vous pourriez rencontrer certaines différences. Vous pouvez consulter la documentation pour les guides pour migrer de 3.x et migrer de 4.x.

      Ce tutoriel a été vérifié avec Node v14.7.0, npm v6.14.7, react v16.13.1, react-native v0.63.2, @react-navigation/native v5.7.3 et @react-navigation/stack v5.9.0.

      Étape 1 – Création d’une nouvelle application React Native

      Tout d’abord, créez une nouvelle application React Native en entrant la commande suivante dans votre terminal :

      • npx react-native init MySocialNetwork --version 0.63.2

      Ensuite, naviguez vers le nouveau répertoire :

      Et lancez l'application pour iOS :

      Ou alors, pour Android :

      Note : Si vous rencontrez des problèmes, vous devrez peut-être consulter Résolution de problèmes pour React Native CLI.

      Cela permettra de créer un projet squelette pour vous. Il ne ressemble pas beaucoup à un réseau social pour l'instant. Réglons ça.

      Ouvrez App.js :

      Remplacez le contenu d’App.js avec le code suivant pour afficher un message de bienvenue :

      App.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class App extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Welcome to MySocialNetwork!</Text>
            </View>
          );
        }
      }
      
      const styles = StyleSheet.create({
        container: {
          flex: 1,
          backgroundColor: '#fff',
          alignItems: 'center',
          justifyContent: 'center',
        },
      });
      
      export default App;
      

      Sauvegardez le fichier. Maintenant, lorsque vous exécutez l'application, un Welcome to MySocialNetwork! MySocialNetwork! apparaîtra dans votre simulateur.

      Dans l'étape suivante, vous ajouterez d'autres écrans à votre application.

      Étape 2 - Création d'un HomeScreen et FriendsScreen

      Actuellement, vous disposez d'un seul écran affichant un message de bienvenue. Au cours de cette étape, vous créerez les deux écrans de votre application : HomeScreen et FriendsScreen.

      HomeScreen

      Votre application aura besoin d'un HomeScreen. Le HomeScreen affichera le nombre d'amis déjà présents dans votre réseau.

      Prenez le code d’App.js et ajoutez-le à un nouveau fichier appelé HomeScreen.js :

      Ouvrez HomeScreen.js:

      Modifiez HomeScreen.js pour utiliser HomeScreen au lieu d’App :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class HomeScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have (undefined) friends.</Text>
            </View>
          );
        }
      }
      
      // ...
      
      export default HomeScreen;
      

      Ce code produira un message de remplacement You have (undefined) friends. Vous fournirez une valeur plus tard.

      FriendsScreen

      Votre application aura également besoin d'un FriendsScreen. Sur le FriendsScreen, vous pourrez ajouter de nouveaux amis.

      Prenez le code de App.js et ajoutez-le à un nouveau fichier appelé FriendsScreen.js :

      • cp App.js FriendsScreen.js

      Ouvrez FriendsScreen.js :

      Modifiez FriendsScreen.js pour utiliser FriendsScreen au lieu d’App :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class FriendsScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
            </View>
          );
        }
      }
      
      // ...
      
      export default FriendsScreen;
      

      Ce code produira un Add friends here! here!

      À ce stade, vous avez un HomeScreen et FriendsScreen. Cependant, il n'y a pas moyen de naviguer entre eux. Vous développerez cette fonctionnalité au cours de la prochaine étape.

      Étape 3 - Utilisation des StackNavigator avec React Navigation

      Pour naviguer entre les écrans, vous utiliserez un StackNavigator. Un StackNavigator fonctionne exactement comme une pile d'appels. Chaque écran vers lequel vous naviguez est poussé vers le haut de la pile. Chaque fois que vous appuyez sur le bouton Retour, les écrans se détachent du haut de la pile.

      Tout d'abord, installez @react-navigation/native :

      • npm install @react-navigation/native@5.7.3

      Ensuite, installez @react-navigation/stack et ses dépendances :

      • npm install @react-navigation/stack@5.9.0 @react-native-community/masked-view@0.1.10 react-native-screens@2.10.1 react-native-safe-area-context@3.1.4 react-native-gesture-handler@1.7.0

      Remarque : Si vous développez pour iOS, vous pouvez avoir besoin de naviguer vers le répertoireios et exécuter pod install.

      Ensuite, revisitez App.js :

      Ajoutez NavigationContainer et createStackNavigator à App.js :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      
      const Stack = createStackNavigator();
      

      Ensuite, remplacez le contenu de render :

      App.js

      // ...
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Nichée à l'intérieur <Stack.Navigator>, ajoutez le HomeScreen :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import HomeScreen from './HomeScreen';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
                <Stack.Screen
                  name="Home"
                  component={HomeScreen}
                />
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Ce code crée une très petite pile pour votre navigateur avec un seul écran : HomeScreen.

      Nichée à l'intérieur <Stack.Navigator>, ajoutez le FriendsScreen :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import HomeScreen from './HomeScreen';
      import FriendsScreen from './FriendsScreen';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
                <Stack.Screen
                  name="Home"
                  component={HomeScreen}
                />
                <Stack.Screen
                  name="Friends"
                  component={FriendsScreen}
                />
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Ce code ajoute le FriendsScreen au navigateur.

      Remarque : Cela diffère de la façon dont createStackNavigator a été utilisé dans les versions précédentes de React Navigation.

      Maintenant, le navigateur est conscient de vos deux écrans.

      Ajouter des boutons à HomeScreen et FriendsScreen

      Enfin, ajoutez des boutons pour vous déplacer entre vos deux écrans.

      Dans HomeScreen.js, ajoutez le code suivant :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      
      class HomeScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have (undefined) friends.</Text>
      
              <Button
                title="Add some friends"
                onPress={() =>
                  this.props.navigation.navigate('Friends')
                }
              />
            </View>
          );
        }
      }
      
      // ...
      

      Dans FriendsScreen.js, ajoutez le code suivant :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      
      class FriendsScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
      
              <Button
                title="Back to home"
                onPress={() =>
                  this.props.navigation.navigate('Home')
                }
              />
            </View>
          );
        }
      }
      
      // ...
      

      Parlons de this.props.navigation. Tant que votre écran est inclus dans le StackNavigatorIl hérite automatiquement de nombreux accessoires utiles de la navigation objet. Dans ce cas, vous avez utilisé navigate pour passer à une autre page.

      HomeScreen et FriendsScreen

      Si vous ouvrez maintenant votre simulateur, vous pouvez naviguer entre le HomeScreen et le FriendsScreen.

      Étape 4 - Utilisation de Context pour transmettre des données à d'autres écrans

      Dans cette étape, vous allez créer un ensemble d'amis possibles - Alice, Bob et Sammy - et une série vide d'amis actuels. Vous créerez également une fonctionnalité permettant à l'utilisateur d'ajouter des amis possibles à ses amis actuels.

      Ouvrez App.js : 

      Ajoutez possibleFriends et currentFriends à l'état du composant :

      App.js

      // ...
      
      class App extends React.Component {
        constructor(props) {
          super(props)
          this.state = {
            possibleFriends: [
              'Alice',
              'Bob',
              'Sammy',
            ],
            currentFriends: [],
          }
        }
      
        // ...
      }
      
      // ...
      

      Ensuite, ajoutez une fonction permettant de déplacer un ami éventuel dans la liste des amis actuels :

      App.js

      // ...
      
      class App extends React.Component {
        constructor(props) {
          super(props)
          this.state = {
            possibleFriends: [
              'Alice',
              'Bob',
              'Sammy',
            ],
            currentFriends: [],
          }
        }
      
        addFriend = (index) => {
          const {
            currentFriends,
            possibleFriends,
          } = this.state
      
          // Pull friend out of possibleFriends
          const addedFriend = possibleFriends.splice(index, 1)
      
          // And put friend in currentFriends
          currentFriends.push(addedFriend)
      
          // Finally, update the app state
          this.setState({
            currentFriends,
            possibleFriends,
          })
        }
      
        // ...
      }
      
      // ...
      

      À ce stade, vous avez terminé la construction de la fonctionnalité permettant d'ajouter des amis.

      Ajouter FriendsContext à App

      Vous pouvez maintenant ajouter des amis dans App.jsmais vous voudrez les ajouter à FriendsScreen.js et les faire afficher dans HomeScreen.js. Comme ce projet est construit avec React, vous pouvez injecter cette fonctionnalité dans vos écrans avec context.

      Note : Dans les versions précédentes de React Navigation, il était possible d'utiliser screenProps pour partager les données entre les écrans. Dans la version actuelle de React Navigation, il est recommandé d'utiliser React Context pour partager les données entre les écrans.

      Pour éviter une référence circulaire, vous voudrez un nouveau fichier FriendsContext :

      Exportez FriendsContext :

      FriendsContext

      import React from 'react';
      
      export const FriendsContext = React.createContext();
      

      Ouvrez App.js : 

      Ajoutez le FriendsContext :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import { FriendsContext } from './FriendsContext';
      import Home from './Home';
      import Friends from './Friends';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        // ...
      
        render() {
          return (
            <FriendsContext.Provider>
              <NavigationContainer>
                <Stack.Navigator>
                  <Stack.Screen
                    name="Home"
                    component={Home}
                  />
                  <Stack.Screen
                    name="Friends"
                    component={Friends}
                  />
                </Stack.Navigator>
              </NavigationContainer>
            </FriendsContext.Provider>
          );
        }
      }
      
      // ...
      

      Ce code établit FriendsContext comme nouvel objet Context et enveloppe le NavigationContainer dans un Context.Provider afin que tous les enfants de l'arbre des composants puissent s'abonner aux changements de contexte.

      Puisque vous n'utilisez plus View ou Text, il est possible de supprimer ces importations de react-native.

      Vous devrez fournir une valeur pour rendre les données accessibles aux consommateurs :

      App.js

      // ...
      
      class App extends React.Component {
        // ...
      
        render() {
          return (
            <FriendsContext.Provider
              value={
                {
                  currentFriends: this.state.currentFriends,
                  possibleFriends: this.state.possibleFriends,
                  addFriend: this.addFriend
                }
              }
            >
              <NavigationContainer>
                <Stack.Navigator>
                  <Stack.Screen
                    name="Home"
                    component={Home}
                  />
                  <Stack.Screen
                    name="Friends"
                    component={Friends}
                  />
                </Stack.Navigator>
              </NavigationContainer>
            </FriendsContext.Provider>
          );
        }
      }
      
      // ...
      

      Cela permettra à la HomeScreen et FriendsScreen de référencer tout changement de contexte currentFriends et possibleFriends.

      Vous pouvez maintenant travailler sur le référencement du contexte dans vos écrans.

      Ajouter FriendsContext à HomeScreen

      Dans cette étape, vous configurerez l'application pour afficher le nombre actuel d'amis.

      Ouvrez HomeScreen.js :

      Et ajoutez le FriendsContext :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class HomeScreen extends React.Component {
        // ...
      }
      HomeScreen.contextType = FriendsContext;
      
      // ...
      

      Ce code établit un Classe.contexteType. Vous pouvez maintenant accéder au contexte dans vos écrans.

      Par exemple, faisons en sorte que votre HomeScreen affiche combien de currentFriends vous avez :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class Home extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have { this.context.currentFriends.length } friends!</Text>
      
              <Button
                title="Add some friends"
                onPress={() =>
                  this.props.navigation.navigate('Friends')
                }
              />
            </View>
          );
        }
      }
      HomeScreen.contextType = FriendsContext;
      
      // ...
      

      Si vous ouvrez à nouveau votre application dans le simulateur et que vous visualisez le HomeScreenvous verrez le message : You have 0 friends!

      Ajoutez FriendsContext à FriendsScreen

      Dans cette étape, vous configurerez l'application pour afficher les amis possibles et fournir des boutons pour les ajouter aux amis actuels.

      Ensuite, ouvrez FriendsScreen.js :

      Et ajoutez le FriendsContext :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class FriendsScreen extends React.Component {
        // ...
      }
      FriendsScreen.contextType = FriendsContext;
      
      // ...
      

      Ce code établit un Class.contextType.

      Maintenant, créez un bouton pour ajouter des amis dans FriendsScreen.js :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class Friends extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
      
              {
                this.context.possibleFriends.map((friend, index) => (
                  <Button
                    key={ friend }
                    title={ `Add ${ friend }` }
                    onPress={() =>
                      this.context.addFriend(index)
                    }
                  />
                ))
              }
      
              <Button
                title="Back to home"
                onPress={() =>
                  this.props.navigation.navigate('Home')
                }
              />
            </View>
          );
        }
      }
      FriendsScreen.contextType = FriendsContext;
      
      // ...
      

      Si vous ouvrez à nouveau votre application dans le simulateur et que vous visualisez le FriendsScreen, vous verrez une liste d'amis à ajouter.

      HomeScreen avec 0 currentFriends et FriendsScreen avec 3 possibleFriends

      Si vous visitez le FriendsScreen et cliquez sur le bouton pour ajouter des amis, vous verrez la liste des possibleFriends diminuer. Si vous visitez le HomeScreen, vous verrez le nombre d'amis augmenter.

      Vous pouvez désormais naviguer entre les écrans et partager des données entre eux.

      Conclusion

      Dans ce tutoriel, vous avez créé un exemple d'application React Native avec plusieurs écrans. En utilisant React Navigation, vous avez imaginé un moyen de naviguer entre les écrans. En utilisant React Context, vous avez développé un moyen de partager des données entre les écrans.

      L'ensemble du code source de ce tutoriel est disponible sur GitHub.

      Si vous souhaitez approfondir votre connaissance de React Navigation, consultez leur documentation.

      React Navigation n'est pas la seule solution de routage et de navigation. Il y a aussi React Native Navigation, React Native Router Fluxet React Router Native.

      Si vous souhaitez en savoir plus sur React, consultez notre série Comment coder dans React.js ou consultez notre page thématique React pour des exercices et des projets de programmation.



      Source link

      Comment générer le rendu de tableaux dans React


      Introduction

      Au cours de cet article, vous allez apprendre à générer le rendu d’un tableau dans React et aborder les meilleures pratiques à utiliser pour générer le rendu de différents éléments dans des composants.

      L’un des avantages d’un langage web moderne comme JavaScript, c’est qu’il vous permet d’automatiser rapidement la génération de blocs HTML.

      En utilisant comme une sorte de boucle sur un tableau ou un objet, il vous suffira d’écrire le HTML une seule fois pour chaque élément. Mieux vaut appliquer les futures modifications qu’une seule fois dès maintenant.

      Rendu de plusieurs éléments

      Pour afficher plusieurs éléments JSX dans React, vous pouvez boucler un tableau en utilisant la méthode .map() et renvoyer un seul élément.

      Ci-dessous, vous parcourez le tableau reptiles et retournez un élément li pour chaque article du tableau. Vous pouvez utiliser cette méthode pour afficher un seul élément pour chaque article du tableau :

      function ReptileListItems() {
        const reptiles = ["alligator", "snake", "lizard"];
      
        return reptiles.map((reptile) => <li>{reptile}</li>);
      }
      

      La sortie finale ressemblera à ceci :

      Output

      - alligator - snake - lizard

      Dans l’exemple suivant, vous allez voir les raisons pour lesquelles vous souhaitez ajouter une key unique à une liste d’éléments rendue sous forme d’un tableau.

      Rendu d’un ensemble d’éléments dans un composant

      Dans cet exemple, vous parcourez un tableau et créez une série de composants d’articles de liste comme dans l’exemple précédent.

      Pour commencer, mettez à jour le code pour utiliser le composant <ol> afin de conserver les articles <li>. Le composant <ol> créera une liste des articles classée :

      function ReptileList() {
        const reptiles = ["alligator", "snake", "lizard"];
      
        return (
          <ol>
            {reptiles.map((reptile) => (
              <li>{reptile}</li>
            ))}
          </ol>
        );
      }
      

      Cependant, si vous regardez la console, vous verrez un avertissement signalant que chaque enfant qui se trouve dans un tableau ou un itérateur doit avoir une clé unique.

      Avertissement dans la console

      L’avertissement apparaît car vous devez ajouter une key à chaque fois que vous tentez d’afficher une collection dans un composant.

      Sous React, la key unique sert à déterminer sur quels composants d’une collection un rendu doit être régénéré. En ajoutant une key unique, React n’a pas à régénérer le rendu de l’ensemble du composant à chaque mise à jour.

      Au cours de cette étape, vous allez générer le rendu de plusieurs éléments dans un composant et ajoutez une key unique. Mettez à jour le code pour inclure une key sur les éléments de la liste afin de stopper l’avertissement :

      function ReptileList() {
        const reptiles = ['alligator', 'snake', 'lizard'];
      
        return (
          <ol>
            {reptiles.map(reptile => (
              <li key={reptile}>{reptile}</li>
            ))}
          </ol>
        );
      }
      
      

      Maintenant que vous avez ajouté une key, l’avertissement n’apparaîtra plus dans la console.

      Dans l’exemple suivant, vous allez découvrir de quelle manière générer le rendu des éléments adjacents sans aucune erreur de syntaxe habituelle.

      Rendu des éléments adjacents

      En JSX, pour générer le rendu de plusieurs éléments d’un composant, vous devez les englober dans un habillage.

      Dans cet exemple, vous devez tout d’abord renvoyer une liste des éléments qui n’ont pas été parcourus par un tableau :

      function ReptileListItems() {
        return (
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
        );
      }
      

      Vous verrez apparaître une erreur persistante dans la console :

      Erreur persistante de React sur des éléments JSX adjacents

      Pour corriger cette erreur, il vous faut envelopper le bloc des éléments li dans un habillage. Lorsqu’il s’agit d’une liste, vous pouvez les envelopper dans un élément ol ou ul :

      function ReptileListItems() {
        return (
        <ol>
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
        </ol>
        );
      }
      

      Maintenant, les éléments <li> adjacents sont enveloppés dans une balise fermée, <ol>, et l’erreur a disparu.

      Dans la section suivante, vous allez générer le rendu d’une liste dans un habillage en utilisant un composant fragment.

      Rendu des éléments adjacents avec React.fragment

      Avant React v16.2, vous pouviez habiller un bloc de composants dans un élément <div>. Cela générait une application pleine de divs, souvent appelée “div soup”.

      Pour résoudre ce problème, React a lancé un nouveau composant connu sous le nom de composant fragment :

      Pour générer le rendu d’une liste à l’intérieur d’une balise close tout en évitant d’utiliser une div, utilisez plutôt React.Fragment :

      function ReptileListItems() {
        return (
        <React.Fragment>
           <li>alligator</li>
           <li>snake</li>
           <li>lizard</li>
        </React.Fragment>
        );
      }
      

      Le code rendu comprendra uniquement les éléments li et le composant React.Fragment n’apparaîtra pas dans le code.

      Rendu d'éléments JSX à l'intérieur d'un habillage React.Fragment

      Notez également que vous n’avez pas besoin d’ajouter une clé avec React.fragment.

      Vous remarquerez qu’il est plus fastidieux d’écrire React.fragment que d’ajouter un <div>. Heureusement, l’équipe React a développé une syntaxe plus courte pour représenter ce composant. Vous pouvez utiliser <> </> à la place de <React.Fragment></React.Fragment> :

      function ReptileListItems() {
        return (
       <>
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
       </>
        );
      }
      

      Conclusion

      Cet article vous a permis de découvrir des méthodes de générer le rendu de tableaux dans une application React.

      Lorsque vous générez le rendu d’un élément dans un autre composant, vous devez utiliser une key unique et envelopper vos éléments dans un élément d’habillage.

      En fonction de votre cas d’utilisation, vous pouvez créer des listes simples habillées dans un composant fragment qui n’a pas besoin de clé.

      Pour en savoir plus sur les meilleures pratiques de React, suivez la série complète Comment coder dans React.js mise à votre disposition sur DigitalOcean.



      Source link

      Comment créer un nouvel utilisateur et octroyer des autorisations dans MySQL


      Introduction

      MySQL est un logiciel de gestion de base de données open-source qui aide les utilisateurs à stocker, organiser et récupérer des données. Un vaste éventail d’options est disponible pour octroyer les autorisations adaptées à des utilisateurs spécifiques dans les tables et les bases de données. Ce tutoriel vous donnera un bref aperçu de quelques-unes des nombreuses options disponibles.

      Qu’est-ce que Highlights signifie ?

      Au cours de ce tutoriel, toutes les lignes que l’utilisateur devra saisir ou personnaliser seront highlighted (mises en surbrillance) ! Le reste devra essentiellement être saisi via du copier-coller.

      Dans la partie 1 du tutoriel MySQL, nous avons procédé à des modifications dans MySQL en tant que root user avec un accès complet à toutes les bases de données. Cependant, dans les cas où vous auriez besoin de configurer des restrictions supplémentaires , il existe des moyens de créer des utilisateurs avec des autorisations personnalisées.

      Commençons par créer un nouvel utilisateur dans le shell MySQL :

      • CREATE USER 'newuser'@'localhost' IDENTIFIED BY 'password';

      Remarque : lorsque nous ajouterons des utilisateurs dans le shell MySQL au cours de ce tutoriel, nous indiquerons que l’hôte de l’utilisateur est localhost et non l’adresse IP du serveur. localhost est un nom d’hôte qui signifie « cet ordinateur ». MySQL traite tout particulièrement ce nom d’hôte spécifique : lorsqu’un utilisateur avec cet hôte se connecte sur MySQL, il tentera de se connecter au serveur local en utilisant un fichier de socket Unix. Par conséquent, de manière générale, vous pouvez utiliser localhost si vous prévoyez de vous connecter à votre serveur en SSH ou exécuter le client mysql local pour vous connecter au serveur MySQL local.

      À ce stade, newuser n’a aucune autorisation et ne peut rien faire sur les bases de données. En effet, même si newuser tente de se connecter (avec le mot de passe password), il ne pourra pas atteindre le shell MySQL.

      Par conséquent, la première chose à faire consiste à donner accès à l’utilisateur aux informations dont il a besoin.

      • GRANT ALL PRIVILEGES ON * . * TO 'newuser'@'localhost';

      Les astérisques de cette commande renvoient à la base de données et à la table (respectivement) auxquelles ils peuvent accéder. Cette commande spécifique permet à l’utilisateur de lire, modifier, exécuter et effectuer toutes tâches sur l’intégralité des bases de données et des tables.

      Notez que, dans cet exemple, nous accordons à newuser un total accès root à tout ce qui se trouve dans notre base de données. Bien que cela soit utile pour expliquer certains concepts MySQL, il se peut que cette méthode soit impraticable sur la plupart des cas d’utilisation et expose votre base de données à d’importants risques de sécurité.

      Une fois que vous en aurez fini avec les autorisations que vous souhaitez configurer pour vos nouveaux utilisateurs, veillez à toujours recharger tous les privilèges.

      Maintenant, vos modifications ont pris effet.

      Voici une courte liste des autres autorisations possibles couramment utilisées que vous pouvez octroyer aux utilisateurs.

      • ALL PRIVILEGES : comme nous l'avons vu précédemment, cela donne à l'utilisateur de MySQL un total accès à une base de données désignée (ou un accès global à l'ensemble du système si aucune base de données n'est sélectionnée)
      • CREATE : permet de créer de nouvelles tables ou bases de données
      • DROP :permet de supprimer des tables ou des bases de données
      • DELETE : permet de supprimer des lignes des tables
      • INSERT : permet d'insérer des lignes dans les tables
      • SELECT :permet d'utiliser la commande SELECT pour lire des bases de données
      • UPDATE : permet de mettre à jour les lignes d'une table
      • GRANT OPTION : permet d'accorder ou de supprimer les privilèges des autres utilisateurs

      Pour donner une autorisation à un utilisateur spécifique, vous pouvez utiliser le framework suivant :

      • GRANT type_of_permission ON database_name.table_name TO 'username'@'localhost';

      Si vous souhaitez lui donner accès à l'une des bases de données ou des tables, veillez à bien remplacer le nom de la base de données ou de la table par un astérisque (*).

      À chaque fois que vous mettez à jour ou modifiez une autorisation, veillez à bien utiliser la commande Flush Privileges.

      Pour révoquer une autorisation, la structure est pratiquement identique à celle de l'octroi d'autorisation :

      • REVOKE type_of_permission ON database_name.table_name FROM 'username'@'localhost';

      Notez que, lorsque vous révoquez des autorisations, vous devez utiliser la syntaxe FROM à la place du TO que nous avons utilisé pour accorder des autorisations.

      Vous pouvez contrôler les autorisations actuellement octroyées à un utilisateur en exécutant la commande suivante :

      • SHOW GRANTS FOR 'username'@'localhost';

      De la même manière que vous pouvez supprimer des bases de données avec DROP, vous pouvez utiliser DROP pour supprimer complètement un utilisateur :

      • DROP USER 'username'@'localhost';

      Pour tester votre nouvel utilisateur, déconnectez-vous en saisissant :

      et reconnectez-vous en utilisant la commande suivante dans le terminal :

      Conclusion

      Une fois ce tutoriel terminé, vous devriez avoir une meilleure idée sur la manière d'ajouter de nouveaux utilisateurs et de leur octroyer différentes autorisations dans une base de données MySQL. De là, vous pouvez continuer d'explorer et d'expérimenter les différents paramètres d'autorisation qui existent pour votre base de données ou en apprendre plus sur certaines configurations MySQL de niveau supérieur.

      Pour de plus amples informations sur les bases de MySQL, nous vous encourageons à consulter les tutoriels suivants :



      Source link