{"meta":{"title":"Comprendiendo la sintaxis de búsqueda de código en GitHub","intro":"Puedes crear consultas de búsqueda para los resultados que quieras con calificadores de código especializados, expresiones regulares y operaciones booleanas.","product":"Buscar en GitHub","breadcrumbs":[{"href":"/es/search-github","title":"Buscar en GitHub"},{"href":"/es/search-github/github-code-search","title":"búsqueda de código de GitHub"},{"href":"/es/search-github/github-code-search/understanding-github-code-search-syntax","title":"Sintaxis de búsqueda de código"}],"documentType":"article"},"body":"# Comprendiendo la sintaxis de búsqueda de código en GitHub\n\nPuedes crear consultas de búsqueda para los resultados que quieras con calificadores de código especializados, expresiones regulares y operaciones booleanas.\n\n## Acerca de la estructura de consultas de búsqueda de código\n\nLa sintaxis de búsqueda de este artículo solo se aplica a la búsqueda de código con la búsqueda de código de GitHub. Ten en cuenta que la sintaxis y los calificadores para buscar contenido que no sea código, como problemas, usuarios y debates, no es la misma que la sintaxis para la búsqueda de código. Para más información sobre la búsqueda que no es de código, consulta [Acerca de la búsqueda en GitHub](/es/search-github/getting-started-with-searching-on-github/about-searching-on-github) y [Buscar en GitHub](/es/search-github/searching-on-github).\n\nLas consultas de búsqueda constan de términos de búsqueda, que incluyen el texto que quieres buscar y calificadores, que limitan la búsqueda.\n\nUn término sin calificadores coincidirá con el contenido de un archivo o la ruta de acceso del archivo.\n\nPor ejemplo, la siguiente consulta:\n\n```text\nhttp-push\n```\n\nLa consulta anterior coincidirá con el archivo `docs/http-push.txt`, incluso si no contiene el término `http-push`. También coincidirá con un archivo llamado `example.txt` si contiene el término `http-push`.\n\nPuedes introducir varios términos separados por espacios en blanco para buscar documentos que cumplan ambos términos.\n\nPor ejemplo, la siguiente consulta:\n\n```text\nsparse index\n```\n\nLos resultados de la búsqueda incluirían todos los documentos que contienen los términos `sparse` y `index`, en cualquier orden. Como ejemplos, coincidiría con un archivo que contenga `SparseIndexVector`, un archivo con la frase `index for sparse trees` e incluso un archivo denominado `index.txt` que contenga el término `sparse`.\n\nLa búsqueda de varios términos separados por espacios en blanco es equivalente a la búsqueda `hello AND world`. Otras operaciones booleanas, como `hello OR world`, también se admiten. Para obtener más información sobre las operaciones booleanas, consulte [Uso de operaciones booleanas](#using-boolean-operations).\n\nLa búsqueda de código también admite la búsqueda de una cadena exacta, incluido el espacio en blanco. Para obtener más información, consulte [Consulta de una coincidencia exacta](#query-for-an-exact-match).\n\nPuedes restringir la búsqueda de código con calificadores especializados, como `repo:`, `language:` y `path:`. Para obtener más información sobre los calificadores que puede usar en la búsqueda de código, consulte [Uso de calificadores](#using-qualifiers).\n\nTambién puedes usar expresiones regulares en las búsquedas rodeando la expresión con barras diagonales. Para obtener más información sobre el uso de expresiones regulares, consulte [Uso de expresiones regulares](#using-regular-expressions).\n\n## Consulta de una coincidencia exacta\n\nPara buscar una cadena exacta, incluido el espacio en blanco, puedes rodear la cadena con comillas. Por ejemplo:\n\n```text\n\"sparse index\"\n```\n\nTambién puedes usar cadenas entre comillas en calificadores, por ejemplo:\n\n```text\npath:git language:\"protocol buffers\"\n```\n\n## Buscar comillas y barras diagonales inversas\n\nPara buscar un código que contenga comillas, puedes establecer la comilla mediante una barra diagonal inversa. Por ejemplo, para buscar la cadena exacta `name = \"tensorflow\"`, puedes buscar:\n\n```text\n\"name = \\\"tensorflow\\\"\"\n```\n\nPara buscar un código que contenga una barra diagonal inversa, `\\`, use una barra diagonal inversa doble, `\\\\`.\n\nLas dos secuencias de escape `\\\\` y `\\\"` también se pueden usar fuera de comillas. Sin embargo, no se reconoce ninguna otra secuencia de escape. Una barra diagonal inversa que no va seguida de `\"` o `\\` se incluye en la búsqueda, sin cambios.\n\nLas secuencias de escape adicionales, como `\\n` para que coincidan con un carácter de nueva línea, se admiten en expresiones regulares. Consulte [Uso de expresiones regulares](#using-regular-expressions).\n\n## Uso de operaciones booleanas\n\nLa búsqueda de código admite expresiones booleanas. Puedes usar los operadores `AND`, `OR` y `NOT` para combinar términos de búsqueda.\n\nDe forma predeterminada, los términos adyacentes separados por espacios en blanco son equivalentes al uso del operador `AND`. Por ejemplo, la consulta de búsqueda `sparse index` es la misma que `sparse AND index`, lo que significa que los resultados de la búsqueda incluirán todos los documentos que contengan los términos `sparse` y `index`, en cualquier orden.\n\nPara buscar documentos que contengan un término u otro, puedes usar el operador `OR`. Por ejemplo, la consulta siguiente coincidirá con los documentos que contengan `sparse` o `index`:\n\n```text\nsparse OR index\n```\n\nPara excluir archivos de los resultados de búsqueda, puedes usar el operador `NOT`. Por ejemplo, para excluir archivos en el directorio `__testing__`, puedes buscar:\n\n```text\n\"fatal error\" NOT path:__testing__\n```\n\nPuedes usar paréntesis para expresar expresiones booleanas más complicadas. Por ejemplo:\n\n```text\n(language:ruby OR language:python) AND NOT path:\"/tests/\"\n```\n\n## Uso de calificadores\n\nPuedes usar palabras clave especializadas para calificar la búsqueda.\n\\*\n[Calificador de repositorio](#repository-qualifier)\n\\*\n[Calificadores de organización y usuario](#organization-and-user-qualifiers)\n\\*\n[Calificador empresarial](#enterprise-qualifier)\n\\*\n[Calificador de lenguaje](#language-qualifier)\n\\*\n[Calificador de licencia](#license-qualifier)\n\\*\n[Calificador de ruta de acceso](#path-qualifier)\n\\*\n[Calificador de símbolos](#symbol-qualifier)\n\\*\n[Calificador de contenido](#content-qualifier)\n\\*\n[Calificador Is](#is-qualifier)\n\n### Calificador de repositorio\n\nPara buscar dentro de un repositorio, usa el calificador `repo:`. Debes proporcionar el nombre completo del repositorio, incluido el propietario. Por ejemplo:\n\n```text\nrepo:github-linguist/linguist\n```\n\nPara buscar en un conjunto de repositorios, puedes combinar varios calificadores `repo:` con el operador booleano `OR`. Por ejemplo:\n\n```text\nrepo:github-linguist/linguist OR repo:tree-sitter/tree-sitter\n```\n\n> \\[!NOTE]\n> Actualmente, la búsqueda de código no admite expresiones regulares o coincidencias parciales para los nombres de repositorio, por lo que tendrá que escribir todo el nombre del repositorio (incluido el prefijo de usuario) para que el calificador `repo:` funcione.\n\n### Calificadores de organización y usuario\n\nPara buscar archivos dentro de una organización, usa el calificador `org:`. Por ejemplo:\n\n```text\norg:github\n```\n\nPara buscar archivos dentro de una cuenta personal, usa el calificador `user:`. Por ejemplo:\n\n```text\nuser:octocat\n```\n\n> \\[!NOTE]\n> Actualmente, la búsqueda de código no admite expresiones regulares o coincidencias parciales para los nombres de la organización o usuario, por lo que tendrá que escribir todo el nombre de la organización o nombre de usuario para que el calificador funcione.\n\n### Calificador empresarial\n\nPara buscar archivos dentro de una empresa, use el `enterprise:` calificador. Por ejemplo:\n\n```text\nenterprise:octocorp\n```\n\nEsto busca repositorios que pertenecen a organizaciones de la `octocorp` empresa. No se incluyen repositorios propiedad del usuario.\n\n### Calificador de lenguaje\n\nPara reducir a un idioma específico, use el `language:` calificador. Por ejemplo:\n\n```text\nlanguage:ruby OR language:cpp OR language:csharp\n```\n\nPara obtener una lista completa de los nombres de lenguajes admitidos, consulta [languages.yaml](https://github.com/github-linguist/linguist/blob/main/lib/linguist/languages.yml) en [github-linguist/linguist](https://github.com/github-linguist/linguist). Si su lenguaje preferido no está en la lista, puedes abrir una solicitud de incorporación de cambios para agregarlo.\n\n### Calificador de licencia\n\nPara filtrar repositorios en función de su licencia o familia de licencias, use el `license:` calificador y la palabra clave de licencia exacta, por ejemplo `Apache-2.0`, , `CC``MIT`.\n\n```text\nlicense:MIT\n```\n\nConsulte [Generar licencia para un repositorio](/es/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/licensing-a-repository#searching-github-by-license-type) para obtener una lista de palabras clave de licencia.\n\n### Calificador de ruta de acceso\n\nPara buscar en rutas de acceso de archivo, usa el calificador `path:`. Esto coincidirá con los archivos que contienen el término en cualquier lugar de la ruta de acceso del archivo. Por ejemplo, para buscar archivos que contengan el término `unit_tests` en su ruta de acceso, usa:\n\n```text\npath:unit_tests\n```\n\nLa consulta anterior coincidirá con `src/unit_tests/my_test.py` y `src/docs/unit_tests.md`, ya que ambas contienen `unit_test` en algún lugar de su ruta de acceso.\n\nPara que solo coincida con un nombre de archivo específico (y no parte de la ruta de acceso), puedes usar una expresión regular:\n\n```text\npath:/(^|\\/)README\\.md$/\n```\n\nTen en cuenta que `.` en el nombre de archivo tiene escape, ya que `.` tiene un significado especial para las expresiones regulares. Para obtener más información sobre el uso de expresiones regulares, consulte [Uso de expresiones regulares](#using-regular-expressions).\n\n
\n\nTambién puedes usar algunas expresiones globales limitadas en el calificador `path:`.\n\nPor ejemplo, para buscar archivos con la extensión `txt`, puedes usar:\n\n```text\npath:*.txt\n```\n\n
\nPara buscar archivos de JavaScript en un directorio `src`, puedes usar:\n\n```text\npath:src/*.js\n```\n\n* De forma predeterminada, las expresiones globales no están ancladas al inicio de la ruta de acceso, por lo que la expresión anterior seguiría coincidiendo con una ruta de acceso como `app/src/main.js`. Pero si prefijas la expresión con `/`, se delimitará al inicio. Por ejemplo:\n\n ```text\n path:/src/*.js\n ```\n\n* Ten en cuenta que `*` no coincide con el carácter `/`, por lo que, para el ejemplo anterior, todos los resultados serán descendientes directos del directorio `src`. Para buscar coincidencias en subdirectorios, de modo que los resultados incluyan archivos profundamente anidados como `/src/app/testing/utils/example.js`, puedes usar `**`. Por ejemplo:\n\n ```text\n path:/src/**/*.js\n ```\n\n
\n\nTambién puedes usar el carácter global `?`. Por ejemplo, para que coincida con la ruta de acceso `file.aac` o `file.abc`, puedes usar:\n\n```text\npath:*.a?c\n```\n\n
\nPara buscar un nombre de archivo que contenga un carácter especial como `*` o `?`, simplemente usa una cadena entre comillas:\n\n```text\npath:\"file?\"\n```\n\nLas expresiones globales están deshabilitadas para las cadenas entre comillas, por lo que la consulta anterior solo coincidirá con las rutas de acceso que contienen la cadena literal `file?`.\n\n### Calificador de símbolos\n\nPuedes buscar definiciones de símbolos en el código, como definiciones de función o de clase, mediante el calificador `symbol:`. La búsqueda de símbolos se basa en el análisis del código mediante el open source [Tree-sitter](https://github.com/tree-sitter) ecosistema del analizador, por lo que no se requiere ninguna integración adicional de la herramienta de configuración o compilación.\n\nPor ejemplo, para buscar un símbolo denominado `WithContext`:\n\n```text\nlanguage:go symbol:WithContext\n```\n\nEn algunos lenguajes, puedes buscar símbolos mediante un prefijo (por ejemplo, un prefijo de su nombre de clase). Por ejemplo, para un método `deleteRows` en una estructura `Maint`, podrías buscar `symbol:Maint.deleteRows` si usas Go o `symbol:Maint::deleteRows` en Rust.\n\nTambién puedes usar expresiones regulares con el calificador de símbolo. Por ejemplo, la consulta siguiente encontraría conversiones que las personas han implementado en Rust para el tipo `String`:\n\n```text\nlanguage:rust symbol:/^String::to_.*/\n```\n\nTen en cuenta que este calificador solo busca definiciones y no referencias, y no todos los tipos de símbolos o lenguajes son totalmente compatibles todavía. La extracción de símbolos es compatible con los siguientes idiomas.\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* Búferes de protocolo\n* Python\n* R\n* Ruby\n* Rust\n* Scala\n* Starlark\n* Swift\n* Typescript\n\nEstamos trabajando en agregar compatibilidad con más lenguajes. Si desea contribuir a este esfuerzo, puede agregar soporte para su idioma en el ecosistema de código abierto [Tree-sitter](https://github.com/tree-sitter), en el que se basa la búsqueda de símbolos.\n\n### Calificador de contenido\n\nDe forma predeterminada, los términos sin sistema buscan en las rutas de acceso y el contenido del archivo. Para restringir una búsqueda para que coincida estrictamente con el contenido de un archivo y no las rutas de acceso de archivo, usa el calificador `content:`. Por ejemplo:\n\n```text\ncontent:README.md\n```\n\nEsta consulta solo coincidiría con los archivos que contienen el término `README.md`, en lugar de los archivos coincidentes denominados `README.md`.\n\n### Calificador Is\n\nPara filtrar en función de las propiedades del repositorio, puedes usar el calificador `is:`.\n`is:` admite los siguientes valores:\n\n* ```\n `archived`: restringe la búsqueda a repositorios archivados.\n ```\n* ```\n `fork`: restringe la búsqueda a repositorios bifurcados.\n ```\n* ```\n `vendored`: restringe la búsqueda al contenido detectado como delegado a proveedores.\n ```\n* ```\n `generated`: restringe la búsqueda al contenido detectado como generado.\n ```\n\nPor ejemplo:\n\n```text\npath:/^MIT.txt$/ is:archived\n```\n\nTen en cuenta que el calificador `is:` se puede invertir con el operador `NOT`. Para buscar repositorios no archivados, puedes buscar:\n\n```text\nlog4j NOT is:archived\n```\n\nPara excluir bifurcaciones de los resultados, puedes buscar:\n\n```text\nlog4j NOT is:fork\n```\n\n## Uso de expresiones regulares\n\nLa búsqueda de código admite expresiones regulares para buscar patrones en el código. Puedes usar expresiones regulares en términos de búsqueda sin sistema operativo, así como en muchos calificadores, rodeando la expresión regular con barras diagonales.\n\nPor ejemplo, para buscar la expresión regular `sparse.*index`, usarías:\n\n```text\n/sparse.*index/\n```\n\nTen en cuenta que tendrá que escapar las barras diagonales dentro de la expresión regular. Por ejemplo, para buscar archivos dentro del directorio `App/src`, usarías:\n\n```text\n/^App\\/src\\//\n```\n\nDentro de una expresión regular, `\\n` significa un carácter de nueva línea, `\\t` significa una pestaña y `\\x{hhhh}` se puede usar para escapar cualquier carácter Unicode. Esto significa que puede usar expresiones regulares para buscar cadenas exactas que contengan caracteres que no se pueden escribir en la barra de búsqueda.\n\nLas características de expresiones regulares más comunes funcionan en la búsqueda de código. Sin embargo, no se admiten las aserciones de “búsqueda en torno”.\n\n## Separación de términos de búsqueda\n\nTodas las partes de una búsqueda, como los términos de búsqueda, las cadenas exactas, las expresiones regulares, los calificadores, los paréntesis y las palabras clave booleanas `AND`, `OR` y `NOT`, deben estar separados entre sí con espacios. La única excepción es que los elementos entre paréntesis, `(``)`, no necesitan estar separados de los paréntesis.\n\nSi la búsqueda contiene varios componentes que no están separados por espacios u otro texto que no siga las reglas enumeradas anteriormente, la búsqueda de código intentará adivinar lo que quiere decir. A menudo se revierte al tratar ese componente de la consulta como texto exacto que se va a buscar. Por ejemplo, la siguiente consulta:\n\n```text\nprintf(\"hello world\\n\");\n```\n\nLa búsqueda de código dejará de interpretar los paréntesis y comillas como caracteres especiales y, en su lugar, buscará archivos que contengan ese código exacto.\n\nSi la búsqueda de código supone un error, siempre puedes obtener la búsqueda que querías usando comillas y espacios para aclarar el significado.\n\n## Distinción entre mayúsculas y minúsculas\n\nDe forma predeterminada, la búsqueda de código no distingue mayúsculas de minúsculas y en los resultados se incluyen ambas formas. Puedes realizar búsquedas con distinción entre mayúsculas y minúsculas mediante una expresión regular con la opción de no distinguir entre ambas desactivada. Por ejemplo, para buscar la cadena \"True\" se usaría:\n\n```text\n/(?-i)True/\n```"}