{"meta":{"title":"Grundlegende GitHub Codesuche-Syntax","intro":"Sie können Suchabfragen für die gewünschten Ergebnisse mit spezialisierten Codequalifizierern, regulären Ausdrücken und booleschen Vorgängen erstellen.","product":"Auf GitHub suchen","breadcrumbs":[{"href":"/de/search-github","title":"Auf GitHub suchen"},{"href":"/de/search-github/github-code-search","title":"GitHub Codesuche"},{"href":"/de/search-github/github-code-search/understanding-github-code-search-syntax","title":"Syntax für die Codesuche"}],"documentType":"article"},"body":"# Grundlegende GitHub Codesuche-Syntax\n\nSie können Suchabfragen für die gewünschten Ergebnisse mit spezialisierten Codequalifizierern, regulären Ausdrücken und booleschen Vorgängen erstellen.\n\n## Informationen zur Struktur von Codesuchabfragen\n\nDie Suchsyntax in diesem Artikel gilt nur für die Codesuche mit der GitHub-Codesuche. Beachte, dass die Syntax und die Qualifizierer für die Suche nach codefremden Inhalten wie Issues, Benutzern und Diskussionen nicht mit der Syntax der Codesuche identisch sind. Weitere Informationen zur Suche nach codefremden Inhalten findest du unter [Informationen zum Suchen auf GitHub](/de/search-github/getting-started-with-searching-on-github/about-searching-on-github) und [Auf GitHub suchen](/de/search-github/searching-on-github).\n\nSuchabfragen bestehen aus Suchbegriffen, die Text enthalten, nach dem Sie suchen möchten, sowie aus Qualifizierern, die die Suche einschränken.\n\nEin reiner Begriff ohne Qualifizierer entspricht entweder dem Inhalt einer Datei oder dem Pfad der Datei.\n\nDie folgende Abfrage ist beispielsweise:\n\n```text\nhttp-push\n```\n\nDie obige Abfrage ermittelt die Datei `docs/http-push.txt`, auch wenn sie nicht den Begriff `http-push` enthält. Sie ermittelt außerdem eine Datei namens `example.txt`, wenn sie den Begriff `http-push` enthält.\n\nSie können mehrere Begriffe durch Leerzeichen getrennt eingeben, um nach Dokumenten zu suchen, die beide Begriffe enthalten.\n\nDie folgende Abfrage ist beispielsweise:\n\n```text\nsparse index\n```\n\nDie Suchergebnisse beinhalten alle Dokumente, die die beiden Begriffe `sparse` und `index` in beliebiger Reihenfolge enthalten. Ein Beispiel wäre eine Datei, die `SparseIndexVector` entspricht, eine Datei mit dem Ausdruck `index for sparse trees` und sogar eine Datei, die `index.txt` heißt und den Begriff `sparse` enthält.\n\nDie Suche nach mehreren Begriffen, die durch Leerzeichen getrennt sind, entspricht der Suche nach `hello AND world`. Andere boolesche Vorgänge, z. B `hello OR world`, werden ebenfalls unterstützt. Weitere Informationen zu booleschen Vorgängen findest du unter [Verwenden boolescher Vorgänge](#using-boolean-operations).\n\nDie Codesuche unterstützt auch die Suche nach einer genauen Zeichenfolge, einschließlich Leerraumzeichen. Weitere Informationen findest du unter [Abfragen einer genauen Übereinstimmung](#query-for-an-exact-match).\n\nSie können die Codesuche mit spezialisierten Qualifizierern wie `repo:`, `language:` und `path:` einschränken. Weitere Informationen zu den Qualifizierern, die du in der Codesuche verwenden kannst, findest du unter [Verwenden von Qualifizierern](#using-qualifiers).\n\nSie können auch reguläre Ausdrücke in Ihren Suchvorgängen verwenden, indem Sie den Ausdruck in Schrägstriche einschließen. Weitere Informationen zur Verwendung regulärer Ausdrücke findest du unter [Verwendung regulärer Ausdrücke](#using-regular-expressions).\n\n## Abfrage nach einer genauen Übereinstimmung\n\nUm nach einer genauen Zeichenfolge zu suchen, einschließlich Leerzeichen, können Sie die Zeichenfolge in Anführungszeichen setzen. Zum Beispiel:\n\n```text\n\"sparse index\"\n```\n\nSie können auch Zeichenfolgen in Anführungszeichen in Qualifizierern verwenden, z. B.:\n\n```text\npath:git language:\"protocol buffers\"\n```\n\n## Suchen nach Anführungszeichen und umgekehrten Schrägstrichen\n\nUm nach einem Code zu suchen, der ein Anführungszeichen enthält, können Sie das Anführungszeichen mit einem umgekehrten Schrägstrich als Escapezeichen versehen. Wenn Sie beispielsweise die genaue Zeichenfolge `name = \"tensorflow\"` finden möchten, können Sie wie folgt suchen:\n\n```text\n\"name = \\\"tensorflow\\\"\"\n```\n\nUm nach Code zu suchen, der einen umgekehrten Schrägstrich enthält, `\\` verwenden Sie einen doppelten umgekehrten Schrägstrich. `\\\\`\n\nDie beiden Escapesequenzen `\\\\` und `\\\"` können auch außerhalb von Anführungszeichen verwendet werden. Es werden jedoch keine anderen Escapesequenzen erkannt. Ein Backslash, auf den in der Suche weder `\"` noch `\\` folgt, bleibt unverändert.\n\nZusätzliche Escapesequenzen wie z. B. `\\n` zum Abgleichen eines Zeilenvorschubzeichen, werden in regulären Ausdrücken unterstützt. Weitere Informationen findest du unter [Verwendung regulärer Ausdrücke](#using-regular-expressions).\n\n## Verwenden boolescher Vorgänge\n\nDie Codesuche unterstützt boolesche Ausdrücke. Sie können die Operatoren `AND`, `OR` und `NOT` verwenden, um Suchbegriffe zu kombinieren.\n\nStandardmäßig sind benachbarte Begriffe, die durch Leerzeichen getrennt sind, gleichbedeutend mit der Verwendung des `AND`-Operators. Die Suchabfrage `sparse index` ist beispielsweise identisch mit `sparse AND index`. Das bedeutet, dass die Suchergebnisse alle Dokumente beinhalten, die sowohl den Begriff `sparse` als auch den Begriff `index` in beliebiger Reihenfolge enthalten.\n\nUm nach Dokumenten zu suchen, die entweder den einen oder den anderen Ausdruck enthalten, können Sie den `OR`-Operator verwenden. Die folgende Abfrage findet z. B. Dokumente, die entweder `sparse` oder `index`enthalten:\n\n```text\nsparse OR index\n```\n\nUm Dateien aus den Suchergebnissen auszuschließen, können Sie den `NOT`-Operator verwenden. Zum Ausschließen von Dateien im Verzeichnis `__testing__` können Sie etwa wie folgt suchen:\n\n```text\n\"fatal error\" NOT path:__testing__\n```\n\nSie können Klammern verwenden, um komplexere boolesche Ausdrücke auszudrücken. Zum Beispiel:\n\n```text\n(language:ruby OR language:python) AND NOT path:\"/tests/\"\n```\n\n## Verwenden von Qualifizierern\n\nSie können spezielle Schlüsselwörter verwenden, um Ihre Suche zu qualifizieren.\n\n* [Qualifizierer für Repositories](#repository-qualifier)\n* [Qualifizierer für Organisationen und Benutzer](#organization-and-user-qualifiers)\n* [Enterprise Qualifier](#enterprise-qualifier)\n* [Sprachqualifikator](#language-qualifier)\n* [Lizenz-Qualifier](#license-qualifier)\n* [Pfadqualifizierer](#path-qualifier)\n* [Symbolqualifizierer](#symbol-qualifier)\n* [Inhaltskategorisierer](#content-qualifier)\n* [Is-Qualifizierer](#is-qualifier)\n\n### Qualifizierer für Repositories\n\nVerwende für die Suche in einem Repository den Qualifizierer `repo:`. Sie müssen den vollständigen Repositorynamen angeben, einschließlich des Besitzers. Zum Beispiel:\n\n```text\nrepo:github-linguist/linguist\n```\n\nUm in mehreren Repositorys zu suchen, können Sie mehrere `repo:`-Qualifizierer mit dem booleschen Operator `OR` kombinieren. Zum Beispiel:\n\n```text\nrepo:github-linguist/linguist OR repo:tree-sitter/tree-sitter\n```\n\n> \\[!NOTE]\n> Die Codesuche unterstützt derzeit keine regulären Ausdrücke oder Teilübereinstimmungen für Repositorynamen. Daher musst du den gesamten Repositorynamen (einschließlich des Benutzerpräfixes) eingeben, damit der Qualifizierer `repo:` funktioniert.\n\n### Qualifizierer für Organisationen und Benutzer\n\nVerwende den Qualifizierer `org:`, um nach Dateien innerhalb einer Organisation zu suchen. Zum Beispiel:\n\n```text\norg:github\n```\n\nVerwende den Qualifizierer `user:`, um nach Dateien innerhalb eines persönlichen Kontos zu suchen. Zum Beispiel:\n\n```text\nuser:octocat\n```\n\n> \\[!NOTE]\n> Die Codesuche unterstützt derzeit keine regulären Ausdrücke oder Teilübereinstimmungen für Organisations- oder Benutzernamen. Daher musst du den gesamten Organisations- oder Benutzernamen eingeben, damit der Qualifizierer funktioniert.\n\n### Enterprise-Qualifizierer\n\nVerwenden Sie den `enterprise:` Qualifizierer, um nach Dateien in einem Unternehmen zu suchen. Zum Beispiel:\n\n```text\nenterprise:octocorp\n```\n\nDies durchsucht Repositorys, die im Besitz von Organisationen im `octocorp` Unternehmen sind. Benutzereigene Repositorys sind nicht enthalten.\n\n### Sprachqualifikator\n\nVerwenden Sie den `language:` Qualifizierer, um sich auf eine bestimmte Sprache einzugrenzen. Zum Beispiel:\n\n```text\nlanguage:ruby OR language:cpp OR language:csharp\n```\n\nEine vollständige Liste der unterstützten Sprachnamen finden Sie in [languages.yaml](https://github.com/github-linguist/linguist/blob/main/lib/linguist/languages.yml) unter [github-linguist/linguist](https://github.com/github-linguist/linguist). Wenn Ihre bevorzugte Sprache nicht in der Liste enthalten ist, können Sie einen Pull Request öffnen, um sie hinzuzufügen.\n\n### Lizenz-Qualifier\n\nUm Repositories nach ihrer Lizenz oder Lizenzfamilie zu filtern, verwenden Sie den `license:`-Qualifier und das genaue Lizenzschlüsselwort, zum Beispiel `Apache-2.0`, `CC`, `MIT`.\n\n```text\nlicense:MIT\n```\n\nEine Liste der Lizenzstichwörter finden Sie unter [Ein Repository lizenzieren](/de/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/licensing-a-repository#searching-github-by-license-type) .\n\n### Pfadqualifizierer\n\nVerwende den Qualifizierer `path:`, um innerhalb von Dateipfaden zu suchen. Dadurch werden Dateien gefunden, die den Begriff irgendwo im Dateipfad enthalten. Um beispielsweise Dateien zu suchen, die den Begriff `unit_tests` in ihrem Pfad enthalten, verwende Folgendes:\n\n```text\npath:unit_tests\n```\n\nDie obige Abfrage ermittelt sowohl `src/unit_tests/my_test.py` als auch`src/docs/unit_tests.md`, da beide an einer beliebigen Stelle in ihrem Pfad `unit_test` enthalten.\n\nUm nur einen bestimmten Dateinamen (und nicht ein Teil des Pfads) abzugleichen, können Sie einen regulären Ausdruck verwenden:\n\n```text\npath:/(^|\\/)README\\.md$/\n```\n\nBeachte, dass `.` im Dateinamen mit Escapezeichen versehen ist, da `.` für reguläre Ausdrücke eine besondere Bedeutung hat. Weitere Informationen zur Verwendung regulärer Ausdrücke findest du unter [Verwendung regulärer Ausdrücke](#using-regular-expressions).\n\n<br>\n\nSie können auch einige eingeschränkte Glob-Ausdrücke im Qualifizierer `path:` verwenden.\n\nUm beispielsweise nach Dateien mit der Erweiterung `txt` zu suchen, können Sie Folgendes verwenden:\n\n```text\npath:*.txt\n```\n\n<br>\nUm in einem Verzeichnis vom Typ `src` nach JavaScript-Dateien zu suchen, können Sie Folgendes verwenden:\n\n```text\npath:src/*.js\n```\n\n* Standardmäßig sind Glob-Ausdrücke nicht am Anfang des Pfads verankert, sodass der obige Ausdruck weiterhin einem Pfad wie `app/src/main.js` entspricht. Wenn Sie dem Ausdruck jedoch das Präfix `/` voranstellen, erfolgt die Verankerung am Anfang. Zum Beispiel:\n\n  ```text\n  path:/src/*.js\n  ```\n\n* Beachte, dass `*` nicht dem Zeichen `/` entspricht, sodass im obigen Beispiel alle Ergebnisse direkte Nachfolger des Verzeichnisses `src` sind. Zum Abgleich innerhalb von Unterverzeichnissen können Sie `/src/app/testing/utils/example.js` verwenden, damit die Ergebnisse tief geschachtelte Dateien wie `**` enthalten. Zum Beispiel:\n\n  ```text\n  path:/src/**/*.js\n  ```\n\n<br>\n\nSie können auch das globale Zeichen `?` verwenden. Zum Abgleich des Pfads `file.aac` oder `file.abc` können Sie beispielsweise Folgendes verwenden:\n\n```text\npath:*.a?c\n```\n\n<br>\nUm nach einem Dateinamen zu suchen, der ein Sonderzeichen wie `*` oder `?` enthält, verwende einfach eine Zeichenfolge in Anführungszeichen:\n\n```text\npath:\"file?\"\n```\n\nGlob-Ausdrücke sind für Zeichenfolgen in Anführungszeichen deaktiviert, deshalb gleicht die obige Abfrage nur Pfade ab, die die Literalzeichenfolge `file?` enthalten.\n\n### Symbolqualifizierer\n\nSie können mit dem Qualifizierer `symbol:` nach Symboldefinitionen im Code suchen, z. B. nach Funktions- oder Klassendefinitionen. Die Symbolsuche basiert auf der Analyse Ihres Codes mithilfe des open source [Tree-sitter](https://github.com/tree-sitter) Parser-Ökosystems, sodass keine zusätzliche Einrichtungs- oder Buildtoolintegration erforderlich ist.\n\nSo suchen Sie beispielsweise nach einem Symbol namens `WithContext`:\n\n```text\nlanguage:go symbol:WithContext\n```\n\nIn einigen Sprachen können Sie mithilfe eines Präfixes (z. B. einem Präfix ihres Klassennamens) nach Symbolen suchen. Beispielsweise können Sie für die Methode `deleteRows` in einer Struktur vom Typ `Maint` nach `symbol:Maint.deleteRows` suchen, wenn Sie Go verwenden. In Rust können Sie nach `symbol:Maint::deleteRows` suchen.\n\nSie können auch reguläre Ausdrücke mit dem Symbolqualifizierer verwenden. Die folgende Abfrage findet z. B. Konvertierungen, die Personen in Rust für den Typ `String` implementiert haben:\n\n```text\nlanguage:rust symbol:/^String::to_.*/\n```\n\nBeachte, dass mit diesem Qualifizierer nur nach Definitionen und nicht nach Verweisen gesucht wird und noch nicht alle Symboltypen und Sprachen vollständig unterstützt werden. Die Symbolextraktion wird für die folgenden Sprachen unterstützt:\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* Protokollpuffer\n* Python\n* R\n* Ruby\n* Rust\n* Scala\n* Starlark\n* Swift\n* Typescript\n\nWir arbeiten daran, Unterstützung für weitere Sprachen hinzuzufügen. Wenn Sie zu diesem Aufwand beitragen möchten, können Sie Unterstützung für Ihre Sprache im open source [Tree-sitter](https://github.com/tree-sitter) Parser-Ökosystem hinzufügen, auf dem die Symbolsuche basiert.\n\n### Inhaltskategorisierer\n\nStandardmäßig durchsuchen reine Begriffe sowohl Pfade als auch Dateiinhalte. Verwende den Qualifizierer `content:`, um eine Suche so einzuschränken, dass sie dem Inhalt einer Datei und nicht den Dateipfaden entspricht. Zum Beispiel:\n\n```text\ncontent:README.md\n```\n\nDiese Abfrage würde nur Dateien ermitteln, die den Begriff `README.md` enthalten, und nicht Dateien namens `README.md`.\n\n### Is-Qualifizierer\n\nZum Filtern basierend auf Repositoryeigenschaften können Sie den Qualifizierer `is:` verwenden.\n`is:` unterstützt die folgenden Werte:\n\n* `archived`: beschränkt die Suche auf archivierte Repositorys.\n* `fork`: beschränkt die Suche auf geforkte Repositories.\n* `vendored`: beschränkt die Suche auf Inhalte, die als Vendor-Inhalte erkannt wurden.\n* `generated`: beschränkt die Suche auf Inhalte, die als generiert erkannt wurden.\n\nZum Beispiel:\n\n```text\npath:/^MIT.txt$/ is:archived\n```\n\nBeachte, dass der Qualifizierer `is:` mit dem `NOT`-Operator umgekehrt werden kann. Für die Suche nach nicht archivierten Repositorys können Sie Folgendes verwenden:\n\n```text\nlog4j NOT is:archived\n```\n\nUm Forks aus Ihren Ergebnissen auszuschließen, können Sie folgendermaßen suchen:\n\n```text\nlog4j NOT is:fork\n```\n\n## Verwendung regulärer Ausdrücke\n\nDie Codesuche unterstützt reguläre Ausdrücke, um nach Mustern im Code zu suchen. Sie können reguläre Ausdrücke sowohl in reinen Suchbegriffen als auch in vielen Qualifizierern verwenden, indem Sie den regulären Ausdruck in Schrägstriche setzen.\n\nUm beispielsweise nach dem regulären Ausdruck `sparse.*index` zu suchen, verwenden Sie Folgendes:\n\n```text\n/sparse.*index/\n```\n\nBeachten Sie, dass Sie alle Schrägstriche innerhalb des regulären Ausdrucks mit Escapezeichen versehen müssen. Um beispielsweise nach Dateien im Verzeichnis `App/src` zu suchen, verwenden Sie Folgendes:\n\n```text\n/^App\\/src\\//\n```\n\nInnerhalb eines regulären Ausdrucks steht `\\n` für ein Zeilenvorschubzeichen, `\\t` für eine Registerkarte und `\\x{hhhh}` kann verwendet werden, um jedes Unicode-Zeichen zu escapen. Dies bedeutet, dass Sie reguläre Ausdrücke verwenden können, um nach exakten Zeichenfolgen zu suchen, die Zeichen enthalten, die Sie nicht in die Suchleiste eingeben können.\n\nDie meisten gängigen Features regulärer Ausdrücke funktionieren in der Codesuche. „Look-around“-Assertionen werden dabei jedoch nicht unterstützt.\n\n## Trennen von Suchbegriffen\n\nAlle Teile einer Suche, z. B. Suchbegriffe, genaue Zeichenfolgen, reguläre Ausdrücke, Qualifizierer, Klammern und die booleschen Schlüsselwörter `AND`, `OR` und `NOT`, müssen durch Leerzeichen voneinander getrennt werden. Die einzige Ausnahme besteht darin, dass in Klammern gesetzte Elemente, `(``)`, nicht von den Klammern getrennt werden müssen.\n\nWenn Ihre Suche mehrere Komponenten enthält, die nicht durch Leerzeichen getrennt sind, oder anderen Text, der nicht den oben aufgeführten Regeln entspricht, versucht die Codesuche zu erraten, was Sie meinen. Sie greift dabei oft darauf zurück, diese Komponente Ihrer Abfrage als den genauen Text zu behandeln, nach dem gesucht werden soll. Die folgende Abfrage ist beispielsweise:\n\n```text\nprintf(\"hello world\\n\");\n```\n\nBei der Codesuche werden die Klammern und Anführungszeichen nicht als Sonderzeichen interpretiert; stattdessen wird nach Dateien gesucht, die diesen genauen Code enthalten.\n\nWenn von der Codesuche der falsche Code erraten wird, können Sie immer noch Anführungszeichen und Leerzeichen einsetzen, um die Bedeutung deutlich zu machen.\n\n## Groß-/Kleinschreibung\n\nStandardmäßig wird bei der Codesuche die Groß-/Kleinschreibung nicht beachtet, und die Ergebnisse enthalten sowohl Groß- als auch Kleinbuchstaben. Du kannst eine die Groß-/Kleinschreibung beachtende Suche durchführen, indem du einen regulären Ausdruck verwendest und die Nichtbeachtung der Groß-/Kleinschreibung deaktivierst. Um beispielsweise nach der Zeichenfolge „True“ zu suchen, würdest du Folgendes verwenden:\n\n```text\n/(?-i)True/\n```"}