{"meta":{"title":"Présentation de la syntaxe de recherche de code GitHub","intro":"Vous pouvez créer des requêtes de recherche pour les résultats souhaités à l’aide de qualificateurs de code spécialisés, d’expressions régulières et d’opérations booléennes.","product":"Rechercher sur GitHub","breadcrumbs":[{"href":"/fr/search-github","title":"Rechercher sur GitHub"},{"href":"/fr/search-github/github-code-search","title":"Recherche de code GitHub"},{"href":"/fr/search-github/github-code-search/understanding-github-code-search-syntax","title":"Syntaxe de recherche de code"}],"documentType":"article"},"body":"# Présentation de la syntaxe de recherche de code GitHub\n\nVous pouvez créer des requêtes de recherche pour les résultats souhaités à l’aide de qualificateurs de code spécialisés, d’expressions régulières et d’opérations booléennes.\n\n## À propos de la structure des requêtes de la recherche de code\n\nLa syntaxe de recherche de cet article s’applique uniquement à la recherche de code avec la recherche de code GitHub. Notez que la syntaxe et les qualificateurs pour rechercher du contenu autre que du code, comme les problèmes, les utilisateurs et les discussions, est différente de la syntaxe pour rechercher du code. Pour plus d’informations sur la recherche sans code, consultez [À propos de la recherche sur GitHub](/fr/search-github/getting-started-with-searching-on-github/about-searching-on-github) et [Recherche sur GitHub](/fr/search-github/searching-on-github).\n\nLes requêtes de recherche se composent de termes de recherche, notamment du texte à rechercher et de qualificateurs, qui permettent d’affiner la recherche.\n\nUn terme utilisé en l’état, sans qualificateur, est recherché dans le contenu ou le chemin d’un fichier.\n\nPar exemple, dans la requête qui suit :\n\n```text\nhttp-push\n```\n\nLa requête ci-dessus va rechercher le fichier `docs/http-push.txt`, même s’il ne contient pas le terme `http-push`. Elle va également rechercher un fichier nommé `example.txt`, s’il contient le terme `http-push`.\n\nVous pouvez entrer plusieurs termes séparés par des espaces blancs pour rechercher les documents qui correspondent aux deux termes.\n\nPar exemple, dans la requête qui suit :\n\n```text\nsparse index\n```\n\nLes résultats de la recherche incluent tous les documents contenant les termes `sparse` et `index`, dans n’importe quel ordre. Par exemple, la requête va rechercher un fichier contenant `SparseIndexVector`, un fichier avec l’expression `index for sparse trees` et même un fichier nommé `index.txt` contenant le terme `sparse`.\n\nLa recherche de plusieurs termes séparés par des espaces blancs équivaut à la recherche `hello AND world`. D’autres opérations booléennes, comme `hello OR world`, sont également prises en charge. Pour plus d’informations sur les opérations booléennes, consultez [Utilisation des opérations booléennes](#using-boolean-operations).\n\nLa recherche de code prend également en charge la recherche d’une chaîne exacte ainsi que les espaces blancs. Pour plus d’informations, consultez [Rechercher une correspondance exacte](#query-for-an-exact-match).\n\nVous pouvez affiner votre recherche de code à l’aide de qualificateurs spécialisés, par exemple `repo:`, `language:` et `path:`. Pour plus d’informations sur les qualificateurs que vous pouvez utiliser dans la recherche de code, consultez [Utilisation de qualificateurs](#using-qualifiers).\n\nVous pouvez également utiliser des expressions régulières dans vos recherches en plaçant ces expressions entre barres obliques. Pour plus d’informations sur l’utilisation des expressions régulières, consultez [Utilisation d’expressions régulières](#using-regular-expressions).\n\n## Rechercher une correspondance exacte\n\nPour rechercher une chaîne exacte, notamment des espaces blancs, vous pouvez placer la chaîne entre guillemets. Voici un exemple :\n\n```text\n\"sparse index\"\n```\n\nVous pouvez également utiliser des chaînes entre guillemets dans les qualificateurs, par exemple :\n\n```text\npath:git language:\"protocol buffers\"\n```\n\n## Recherche de guillemets et de barres obliques inverses\n\nPour rechercher du code contenant un guillemet, vous pouvez utiliser la barre oblique inverse en tant que caractère d’échappement devant le guillemet. Par exemple, pour trouver la chaîne exacte `name = \"tensorflow\"`, vous pouvez effectuer la recherche suivante :\n\n```text\n\"name = \\\"tensorflow\\\"\"\n```\n\nPour rechercher du code contenant une barre oblique inverse, `\\`, utilisez une double barre oblique inverse, `\\\\`.\n\nLes deux séquences d’échappement `\\\\` et `\\\"` peuvent également être utilisées en dehors des guillemets. Cependant, aucune autre séquence d’échappement n’est reconnue. Une barre oblique inverse qui n’est pas suivie de `\"` ou de `\\` est incluse dans la recherche, sans modification.\n\nDes séquences d’échappement supplémentaires, telles que `\\n` qui correspond à un caractère de nouvelle ligne, sont prises en charge dans les expressions régulières. Voir [Utilisation des expressions régulières](#using-regular-expressions)\n\n## Utilisation d’opérations booléennes\n\nLa recherche de code prend en charge les expressions booléennes. Vous pouvez utiliser les opérateurs `AND`, `OR` et `NOT` pour combiner les termes de recherche.\n\nPar défaut, les termes adjacents séparés par des espaces blancs équivalent à l’utilisation de l’opérateur `AND`. Par exemple, la requête de recherche `sparse index` est identique à `sparse AND index`, ce qui signifie que les résultats de la recherche vont inclure tous les documents contenant les termes `sparse` et `index`, dans n’importe quel ordre.\n\nPour rechercher des documents contenant l’un ou l’autre de ces termes, vous pouvez utiliser l’opérateur `OR`. Par exemple, la requête suivante recherche les documents contenant `sparse` ou `index` :\n\n```text\nsparse OR index\n```\n\nPour exclure des fichiers des résultats de la recherche, vous pouvez utiliser l’opérateur `NOT`. Par exemple, pour exclure des fichiers du répertoire `__testing__`, vous pouvez effectuer la recherche suivante :\n\n```text\n\"fatal error\" NOT path:__testing__\n```\n\nVous pouvez utiliser des parenthèses pour exprimer des expressions booléennes plus complexes. Voici un exemple :\n\n```text\n(language:ruby OR language:python) AND NOT path:\"/tests/\"\n```\n\n## Utilisation de qualificateurs\n\nVous pouvez utiliser des mots clés spécialisés pour qualifier votre recherche.\n\\*\n[Qualificateur de dépôt](#repository-qualifier)\n\\*\n[Qualificateurs d’organisation et d’utilisateur](#organization-and-user-qualifiers)\n\\*\n[Identifiant d’entreprise](#enterprise-qualifier)\n\\*\n[Qualificateur de langage](#language-qualifier)\n\n* ```\n            [Qualificateur de licence](#license-qualifier)\n  ```\n* ```\n          [Qualificateur de chemin](#path-qualifier)\n  ```\n* ```\n          [Qualificateur de symbole](#symbol-qualifier)\n  ```\n* ```\n          [Qualificateur de contenu](#content-qualifier)\n  ```\n* ```\n          [Qualificateur is](#is-qualifier)\n  ```\n\n### Qualificateur de dépôt\n\nPour effectuer une recherche dans un dépôt, utilisez le qualificateur `repo:`. Vous devez fournir le nom complet du dépôt en indiquant également son propriétaire. Voici un exemple :\n\n```text\nrepo:github-linguist/linguist\n```\n\nPour effectuer une recherche dans un ensemble de dépôts, vous pouvez combiner plusieurs qualificateurs `repo:` avec l’opérateur booléen `OR`. Voici un exemple :\n\n```text\nrepo:github-linguist/linguist OR repo:tree-sitter/tree-sitter\n```\n\n> \\[!NOTE]\n> La recherche de code ne prend pas en charge les expressions régulières ou la correspondance partielle pour les noms de dépôts. Vous devez donc taper le nom complet du dépôt (en indiquant également le préfixe utilisateur) pour que le qualificateur `repo:` fonctionne.\n\n### Qualificateurs d’organisation et d’utilisateur\n\nPour rechercher des fichiers dans une organisation, utilisez le qualificateur `org:`. Voici un exemple :\n\n```text\norg:github\n```\n\nPour rechercher des fichiers dans un compte personnel, utilisez le qualificateur `user:`. Voici un exemple :\n\n```text\nuser:octocat\n```\n\n> \\[!NOTE]\n> La recherche de code ne prend pas en charge les expressions régulières ou la correspondance partielle pour les noms d’organisations ou d’utilisateurs. Vous devez donc taper le nom d’organisation ou le nom d’utilisateur complet pour que le qualificateur fonctionne.\n\n### Identifiant d’entreprise\n\nPour rechercher des fichiers au sein d’une entreprise, utilisez le `enterprise:` qualificateur. Voici un exemple :\n\n```text\nenterprise:octocorp\n```\n\nCette opération recherche les référentiels appartenant aux organisations de l’entreprise `octocorp` . Les référentiels appartenant à l’utilisateur ne sont pas inclus.\n\n### Qualificateur de langage\n\nPour limiter à une langue spécifique, utilisez le `language:` qualificateur. Voici un exemple :\n\n```text\nlanguage:ruby OR language:cpp OR language:csharp\n```\n\nPour obtenir la liste complète des noms de langages pris en charge, consultez [languages.yaml](https://github.com/github-linguist/linguist/blob/main/lib/linguist/languages.yml) dans [github-linguist/linguist](https://github.com/github-linguist/linguist). Si le langage souhaité ne figure pas dans la liste, vous pouvez ouvrir une demande de tirage (pull request) pour l’ajouter.\n\n### Qualificateur de licence\n\nPour filtrer les référentiels en fonction de leur licence ou de leur famille de licences, utilisez le qualificateur et le `license:` mot clé de licence exact, par exemple `Apache-2.0`, . `CC``MIT`\n\n```text\nlicense:MIT\n```\n\nConsultez [Gestion des licences d’un référentiel](/fr/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/licensing-a-repository#searching-github-by-license-type) pour obtenir la liste des mots clés de licence.\n\n### Qualificateur de chemin\n\nPour effectuer une recherche dans les chemins de fichiers, utilisez le qualificateur `path:`. Cela permet de rechercher les fichiers contenant le terme n’importe où dans leur chemin. Par exemple, pour rechercher les fichiers contenant le terme `unit_tests` dans leur chemin, utilisez :\n\n```text\npath:unit_tests\n```\n\nLa requête ci-dessus trouve `src/unit_tests/my_test.py` et `src/docs/unit_tests.md`, car ils contiennent tous les deux `unit_test` dans leur chemin.\n\nPour chercher uniquement un nom de fichier spécifique (et non une partie du chemin), vous pouvez utiliser une expression régulière :\n\n```text\npath:/(^|\\/)README\\.md$/\n```\n\nNotez que le `.` dans le nom de fichier fait l’objet d’une séquence d’échappement, car `.` a une signification particulière pour les expressions régulières. Pour plus d’informations sur l’utilisation des expressions régulières, consultez [Utilisation d’expressions régulières](#using-regular-expressions).\n\n<br>\n\nVous pouvez également utiliser certaines expressions Glob limitées dans le qualificateur `path:`.\n\nPar exemple, pour rechercher des fichiers ayant l’extension `txt`, vous pouvez utiliser :\n\n```text\npath:*.txt\n```\n\n<br>\nPour rechercher des fichiers JavaScript dans un répertoire `src`, vous pouvez utiliser :\n\n```text\npath:src/*.js\n```\n\n* Par défaut, les expressions Glob ne sont pas ancrées au début du chemin. Ainsi, l’expression ci-dessus recherche toujours un chemin tel que `app/src/main.js`. Toutefois, si vous faites précéder l’expression de `/`, elle est ancrée au début. Voici un exemple :\n\n  ```text\n  path:/src/*.js\n  ```\n\n* Notez que `*` ne correspond pas au caractère `/`. Ainsi, pour l’exemple ci-dessus, tous les résultats sont des descendants directs du répertoire `src`. Pour rechercher des correspondances dans des sous-répertoires, afin que les résultats incluent des fichiers profondément imbriqués tels que `/src/app/testing/utils/example.js`, vous pouvez utiliser `**`. Voici un exemple :\n\n  ```text\n  path:/src/**/*.js\n  ```\n\n<br>\n\nVous pouvez également utiliser le caractère global `?`. Par exemple, pour rechercher le chemin `file.aac` ou `file.abc`, vous pouvez utiliser :\n\n```text\npath:*.a?c\n```\n\n<br>\nPour rechercher un nom de fichier qui contient un caractère spécial tel que `*` ou `?`, utilisez simplement une chaîne entre guillemets :\n\n```text\npath:\"file?\"\n```\n\nLes expressions Glob sont désactivées pour les chaînes entre guillemets, la requête ci-dessus recherche donc uniquement les chemins contenant la chaîne littérale `file?`.\n\n### Qualificateur de symbole\n\nVous pouvez rechercher des définitions de symboles dans le code, par exemple des définitions de fonctions ou de classes, à l’aide du qualificateur `symbol:`. La recherche de symboles est basée sur l’analyse de votre code à l’aide de l’écosystème open source [Tree-sitter](https://github.com/tree-sitter) de l’analyseur. Par conséquent, aucune installation supplémentaire ni intégration de l’outil de génération n’est requise.\n\nPar exemple, pour rechercher un symbole appelé `WithContext` :\n\n```text\nlanguage:go symbol:WithContext\n```\n\nDans certains langages, vous pouvez rechercher des symboles à l’aide d’un préfixe (par exemple le préfixe de leur nom de classe). Par exemple, pour une méthode `deleteRows` sur un struct `Maint`, vous pouvez rechercher `symbol:Maint.deleteRows` en Go, ou `symbol:Maint::deleteRows` en Rust.\n\nVous pouvez également utiliser des expressions régulières avec le qualificateur de symbole. Par exemple, la requête suivante permet de trouver les conversions que des utilisateurs ont implémentées en Rust pour le type `String` :\n\n```text\nlanguage:rust symbol:/^String::to_.*/\n```\n\nNotez que ce qualificateur recherche uniquement les définitions et non les références. De plus, tous les types de symbole et tous les langages ne sont pas encore complètement pris en charge. L’extraction de symboles est prise en charge pour les langages suivants :\n\n* Bash\n* C\n* C#\n* C++\n* CodeQL\n* Elixir\n* Go\n* JSX\n* Java\n* JavaScript\n* Lua\n* PHP\n* Mémoires tampon de protocole\n* Python\n* R\n* Ruby\n* Rust\n* Scala\n* Starlark\n* Swift\n* Typescript\n\nNous travaillons à la prise en charge d’un plus grand nombre de langages. Si vous souhaitez contribuer à cet effort, vous pouvez ajouter la prise en charge de votre langue dans le open source [Tree-sitter](https://github.com/tree-sitter) écosystème d’analyseur, sur lequel la recherche de symboles est basée.\n\n### Qualificateur de contenu\n\nPar défaut, les termes utilisés en l’état sont recherchés à la fois dans les chemins et les contenus des fichiers. Pour restreindre une recherche afin qu’elle corresponde strictement au contenu d’un fichier et non aux chemins de fichiers, utilisez le qualificateur `content:`. Voici un exemple :\n\n```text\ncontent:README.md\n```\n\nCette requête recherche uniquement les fichiers contenant le terme `README.md` et non les fichiers nommés `README.md`.\n\n### Qualificateur is\n\nPour effectuer un filtrage en fonction des propriétés du dépôt, vous pouvez utiliser le qualificateur `is:`.\n`is:` prend en charge les valeurs suivantes :\n\n* ```\n          `archived` : restreint la recherche aux dépôts archivés.\n  ```\n* ```\n          `fork` : restreint la recherche aux dépôts dupliqués.\n  ```\n* ```\n          `vendored` : restreint la recherche au contenu détecté comme fourni.\n  ```\n* ```\n          `generated` : restreint la recherche au contenu détecté comme généré.\n  ```\n\nVoici un exemple :\n\n```text\npath:/^MIT.txt$/ is:archived\n```\n\nNotez que le qualificateur `is:` peut être inversé par rapport à l’opérateur `NOT`. Pour rechercher des dépôts non archivés, vous pouvez effectuer la recherche suivante :\n\n```text\nlog4j NOT is:archived\n```\n\nPour exclure les duplications de vos résultats, vous pouvez rechercher :\n\n```text\nlog4j NOT is:fork\n```\n\n## Utilisation d’expressions régulières\n\nLa recherche de code prend en charge les expressions régulières pour la recherche de modèles dans votre code. Vous pouvez employer des expressions régulières dans les termes de recherche utilisés en l’état ainsi que dans de nombreux qualificateurs, en plaçant ces regex entre barres obliques.\n\nPar exemple, pour rechercher l’expression régulière `sparse.*index`, vous devez utiliser :\n\n```text\n/sparse.*index/\n```\n\nNotez que les barres obliques utilisées de manière littérale doivent faire l’objet de séquences d’échappement au sein de l’expression régulière. Par exemple, pour rechercher des fichiers dans le répertoire `App/src`, vous devez utiliser :\n\n```text\n/^App\\/src\\//\n```\n\nÀ l’intérieur d’une expression régulière, `\\n` représente un caractère de nouvelle ligne, `\\t` représente une tabulation et `\\x{hhhh}` peut être utilisé pour échapper n’importe quel caractère Unicode. Cela signifie que vous pouvez utiliser des expressions régulières pour rechercher des chaînes exactes qui contiennent des caractères que vous ne pouvez pas saisir dans la barre de recherche.\n\nLes fonctionnalités les plus courantes des expressions régulières fonctionnent dans la recherche de code. Toutefois, les assertions « look-around » ne sont pas prises en charge.\n\n## Séparation des termes de recherche\n\nToutes les parties d’une recherche, telles que les termes de recherche, les chaînes exactes, les expressions régulières, les qualificateurs, les parenthèses et les mot clé booléens `AND`, `OR` et `NOT`, doivent être séparées les unes des autres par des espaces. La seule exception concerne les éléments entre parenthèses, `(``)`, qui n’ont pas besoin d’être séparés des parenthèses.\n\nSi votre recherche contient plusieurs composants qui ne sont pas séparés par des espaces ou d’autre texte qui ne suit pas les règles énumérées ci-dessus, la recherche de code essaie de deviner ce que vous voulez dire. Elle se contente souvent de traiter ce composant de votre requête comme s'il s'agissait du texte exact à rechercher. Par exemple, dans la requête qui suit :\n\n```text\nprintf(\"hello world\\n\");\n```\n\nLa recherche de code renoncera à interpréter les parenthèses et les guillemets comme des caractères spéciaux et recherchera plutôt les fichiers contenant ce code exact.\n\nSi la recherche de code est incorrecte, vous pouvez toujours effectuer la recherche souhaitée en utilisant des guillemets et des espaces pour en clarifier le sens.\n\n## Sensibilité à la casse\n\nPar défaut, la recherche de code ne respecte pas la casse et les résultats incluront dont à la fois les majuscules et les minuscules. Vous pouvez effectuer des recherches sensibles à la casse à l’aide d’une expression régulière en désactivant le non-respect de la casse. Par exemple, pour rechercher la chaîne « True », vous devez utiliser :\n\n```text\n/(?-i)True/\n```"}