# Buscar código

de búsqueda de código. Puede buscar código en GitHub y restringir los resultados mediante estos calificadores de búsqueda de código en cualquier combinación.

Puedes buscar globalmente en la totalidad de GitHub, o bien acotar tu búsqueda a un repositorio u organización en particular. Para obtener más información, consulte [Acerca de la búsqueda en GitHub](/es/enterprise-server@3.22/search-github/getting-started-with-searching-on-github/about-searching-on-github).

Únicamente puedes buscar código utilizando estos calificadores de búsqueda de código. Los calificadores de búsqueda especialmente para repositorios, usuarios o confirmaciones de cambios, no funcionarán cuando busques código.

> \[!TIP]
>
> * Este artículo contiene enlaces a las búsquedas de muestra en el sitio web de GitHub.com, pero puedes utilizar los mismos filtros de búsqueda en cualquier plataforma GitHub. En las búsquedas de ejemplos vinculadas, reemplaza `github.com` con el nombre de host de la plataforma GitHub.
> * Para una lista de sintaxis de búsqueda que puedas agregar a cualquier calificador de búsqueda para mejorar aún más los resultados, consulta [Entender la sintaxis de búsqueda](/es/enterprise-server@3.22/search-github/getting-started-with-searching-on-github/understanding-the-search-syntax).
> * Utiliza comillas alrededor de los términos de búsqueda que contengan varias palabras. Por ejemplo, si quiere buscar incidencias con la etiqueta "En curso", tendría que buscar `label:"in progress"`. Buscar no distingue entre mayúsculas y minúsculas.

## Consideraciones para la búsqueda de código

Debido a la complejidad de la búsqueda de código, hay algunas restricciones sobre cómo se realizan las búsquedas:

* Debes haber iniciado sesión en una cuenta personal en GitHub para buscar el código en todos los repositorios públicos.
* El código de [bifurcaciones](/es/enterprise-server@3.22/pull-requests/collaborating-with-pull-requests/working-with-forks/about-forks) solo se puede buscar si la bifurcación tiene más estrellas que el repositorio primario y el repositorio bifurcado tiene al menos una confirmación insertada después de crearse. Las bifurcaciones con menos estrellas que el repositorio primario o las no confirmaciones **no** se indexan para la búsqueda de código. Para incluir bifurcaciones con más estrellas que sus elementos primarios y al menos una confirmación enviada en los resultados de búsqueda, deberás agregar `fork:true` o `fork:only` a la consulta. Para más información, consulta [Buscar en bifurcaciones](/es/enterprise-server@3.22/search-github/searching-on-github/searching-in-forks).
* Solo se indexa la *rama predeterminada* para la búsqueda de código.
* Solo se pueden buscar archivos menores de Se pueden buscar 5 MB.
* Solo se pueden buscar los primeros 500 KB de cada archivo.
* Se pueden buscar hasta 4000 repositorios privados e internos . Estos 4000 repositorios serán los más recientes actualizados de los primeros 10 000 repositorios privados e internos a los que tiene acceso.
* Solo se pueden buscar repositorios con menos de 500 000 archivos.
* Los repositorios archivados no se pueden buscar.
* Con la excepción de las búsquedas de [`filename`](#search-by-filename), siempre debe incluir por lo menos un término de búsqueda cuando busque en el código fuente. Por ejemplo, la búsqueda de [`language:javascript`](https://github.com/search?utf8=%E2%9C%93\&q=language%3Ajavascript\&type=Code\&ref=searchresults) no es válida, mientras que la de [`amazing language:javascript`](https://github.com/search?utf8=%E2%9C%93\&q=amazing+language%3Ajavascript\&type=Code\&ref=searchresults) sí lo es.
* A lo sumo, los resultados de búsqueda pueden mostrar dos fragmentos del mismo archivo, pero puede haber más resultados dentro del archivo.
* No puede utilizar los siguientes caracteres comodines como parte de la consulta de búsqueda: <code>. , : ; / \ \` ' " = \* ! ? # $ & + ^ | \~ < > ( ) { } \[ ] @</code>. La búsqueda simplemente ignorará estos símbolos.

## Buscar según los contenidos del archivo o la ruta de archivo

Con el calificador `in` puede restringir la búsqueda a los contenidos del archivo del código fuente, de la ruta del archivo o de ambos. Cuando omites este calificador, únicamente se busca el contenido del archivo.

| Calificador:                                                                                                                                                                                       | Ejemplo |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `in:file`                                                                                                                                                                                          |         |
| \[                                                                                                                                                                                                 |         |
| **octocat in:file**]\(<https://github.com/search?q=octocat+in%3Afile&type=Code>) coincide con el código donde "octocat" aparece en el contenido del archivo.                                       |         |
| `in:path`                                                                                                                                                                                          |         |
| \[                                                                                                                                                                                                 |         |
| **octocat in:path**]\(<https://github.com/search?q=octocat+in%3Apath&type=Code>) coteja el código donde "octocat" aparece en la ruta de acceso.                                                    |         |
| `in:file,path`                                                                                                                                                                                     |         |
| \[                                                                                                                                                                                                 |         |
| **octocat in:file, path**]\(<https://github.com/search?q=octocat+in%3Afile%2Cpath&type=Code>) coincide con el código donde "octocat" aparece en el contenido del archivo o en la ruta del archivo. |         |

## Buscar dentro de los repositorios de un usuario u organización

Para buscar el código en todos los repositorios que son propiedad de una determinada organización o usuario, puedes utilizar el calificador `user` o `org`. Para buscar el código en un repositorio específico, puede utilizar el calificador `repo`.

| Calificador:                                                                                                                                                                                                  | Ejemplo |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| <code>user:<em>USERNAME</em></code>                                                                                                                                                                           |         |
| \[                                                                                                                                                                                                            |         |
| **user:defunkt extension:rb**]\(<https://github.com/search?q=user%3Agithub+extension%3Arb&type=Code>) coincide con el código de @defunkt que termina en <em>.rb</em>.                                         |         |
| <code>org:<em>ORGNAME</em></code>                                                                                                                                                                             |         |
| \[                                                                                                                                                                                                            |         |
| **org:github extension:js**]\(<https://github.com/search?utf8=%E2%9C%93&q=org%3Agithub+extension%3Ajs&type=Code>) coincide con el código de GitHub que termina en <em>.js</em>.                               |         |
| <code>repo:<em>USERNAME/REPOSITORY</em></code>                                                                                                                                                                |         |
| \[                                                                                                                                                                                                            |         |
| **repo:mozilla/shumway extension:as**]\(<https://github.com/search?q=repo%3Amozilla%2Fshumway+extension%3Aas&type=Code>) coincide con el código del proyecto shumway de @mozilla que termina en <em>.as</em>. |         |

## Buscar por ubicación del archivo

Puede utilizar el calificador `path` para buscar el código fuente que aparece en una ubicación específica en un repositorio. Utilice `path:/` para buscar archivos que se encuentren en el nivel raíz de un repositorio. O especifica un nombre de directorio o ruta a un directorio para buscar archivos que estén ubicados dentro de ese directorio o alguno de sus subdirectorios.

| Calificador:                                                                                                                                                                                                                                                                                                   | Ejemplo |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| <code>path:/</code>                                                                                                                                                                                                                                                                                            |         |
| \[                                                                                                                                                                                                                                                                                                             |         |
| **octocat filename:readme path:/**]\(<https://github.com/search?utf8=%E2%9C%93&q=octocat+filename%3Areadme+path%3A%2F&type=Code>) coteja los archivos *léame* con la palabra "octocat" que se encuentran en el nivel raíz de un repositorio.                                                                   |         |
| <code>path:<em>DIRECTORY</em></code>                                                                                                                                                                                                                                                                           |         |
| \[                                                                                                                                                                                                                                                                                                             |         |
| **form path:cgi-bin language:perl**]\(<https://github.com/search?q=form+path%3Acgi-bin+language%3Aperl&type=Code>) coincide con los archivos Perl con la palabra "form" en el directorio <em>cgi-bin</em>, o en cualquiera de sus subdirectorios.                                                              |         |
| <code>path:<em>PATH/TO/DIRECTORY</em></code>                                                                                                                                                                                                                                                                   |         |
| \[                                                                                                                                                                                                                                                                                                             |         |
| \*\*                                                                                                                                                                                                                                                                                                           |         |
| `console path:app/public language:javascript`                                                                                                                                                                                                                                                                  |         |
| \*\*                                                                                                                                                                                                                                                                                                           |         |
| ]\(<https://github.com/search?q=console+path%3A%22app%2Fpublic%22+language%3Ajavascript&type=Code>) coincide con los archivos de JavaScript con la palabra "console" en el directorio <em>app/public</em>, o en cualquiera de sus subdirectorios (incluso si están en <em>app/public/js/form-validators</em>). |         |

## Buscar por lenguaje

Puedes buscar el código basado en el lenguaje en que está escrito. El calificador `language` puede ser el nombre o alias del lenguaje. Para obtener una lista completa de los lenguajes admitidos con sus nombres y alias, consulta el [repositorio github-linguist/linguist](https://github.com/github-linguist/linguist/blob/main/lib/linguist/languages.yml).

| Calificador:                                                                                                                                                                                                           | Ejemplo |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| <code>language:<em>LANGUAGE</em></code>                                                                                                                                                                                |         |
| \[                                                                                                                                                                                                                     |         |
| **element language:xml size:100**]\(<https://github.com/search?q=element+language%3Axml+size%3A100&type=Code>) corresponde al código con la palabra «element» que está marcado como XML y tiene exactamente 100 bytes. |         |
| <code>language:<em>LANGUAGE</em></code>                                                                                                                                                                                |         |
| \[                                                                                                                                                                                                                     |         |
| **display language:scss**]\(<https://github.com/search?q=display+language%3Ascss&type=Code>) coincide con el código que contiene la palabra "display", que está marcado como SCSS.                                     |         |
| <code>language:<em>LANGUAGE</em></code>                                                                                                                                                                                |         |
| \[                                                                                                                                                                                                                     |         |
| **org:mozilla language:Markdown**]\(<https://github.com/search?utf8=%E2%9C%93&q=org%3Amozilla+language%3Amarkdown&type=Code>) coincide con el código de todos los repositorios de @mozilla marcados como Markdown.     |         |

## Buscar por tamaño de archivo

Puede utilizar el calificador `size` para buscar código fuente en base al tamaño del archivo donde existe el código. El calificador `size` usa [calificadores mayor que, menor que y de rango](/es/enterprise-server@3.22/search-github/getting-started-with-searching-on-github/understanding-the-search-syntax) para filtrar los resultados en función del tamaño en bytes del archivo en el que se encuentra el código.

| Calificador:                                                                                                                                                                                                                                     | Ejemplo |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------- |
| <code>size:<em>n</em></code>                                                                                                                                                                                                                     |         |
| \[                                                                                                                                                                                                                                               |         |
| **function size:>10000 language:python**]\(<https://github.com/search?q=function+size%3A%3E10000+language%3Apython&type=Code>) corresponde al código que contiene la palabra "function", escrito en Python, en archivos que tienen más de 10 KB. |         |

## Buscar por nombre de archivo

El calificador `filename` coincide con archivos de código con un determinado nombre de archivo. También puedes encontrar un archivo en un repositorio utilizando el buscador de archivo. Para más información, consulta [Buscar archivos en GitHub](/es/enterprise-server@3.22/search-github/searching-on-github/finding-files-on-github).

| Calificador:                                                                                                                                                                                                                                     | Ejemplo |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------- |
| <code>filename:<em>FILENAME</em></code>                                                                                                                                                                                                          |         |
| \[                                                                                                                                                                                                                                               |         |
| **filename:linguist**]\(<https://github.com/search?utf8=%E2%9C%93&q=filename%3Alinguist&type=Code>) coincide con los archivos denominados "linguist".                                                                                            |         |
| <code>filename:<em>FILENAME</em></code>                                                                                                                                                                                                          |         |
| \[                                                                                                                                                                                                                                               |         |
| **filename:.vimrc commands**]\(<https://github.com/search?q=filename%3A.vimrc+commands&type=Code>) coincide con archivos *.vimrc* asociados con el término "commands".                                                                           |         |
| <code>filename:<em>FILENAME</em></code>                                                                                                                                                                                                          |         |
| \[                                                                                                                                                                                                                                               |         |
| **filename:test\_helper path:test language:ruby**]\(<https://github.com/search?q=minitest+filename%3Atest_helper+path%3Atest+language%3Aruby&type=Code>) coincide con los archivos Ruby denominados *test\_helper* en el directorio de *prueba*. |         |

## Buscar por extensión de archivo

El calificador `extension` coincide con archivos de código con una determinada extensión de archivo.

| Calificador:                                                                                                                                                                                                                                  | Ejemplo |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| <code>extension:<em>EXTENSION</em></code>                                                                                                                                                                                                     |         |
| \[                                                                                                                                                                                                                                            |         |
| **form path:cgi-bin extension:pm**]\(<https://github.com/search?q=form+path%3Acgi-bin+extension%3Apm&type=Code>) coincide con el código que contiene la palabra "form", dentro de <em>cgi-bin</em>, con la extensión de archivo <em>.pm</em>. |         |
| <code>extension:<em>EXTENSION</em></code>                                                                                                                                                                                                     |         |
| \[                                                                                                                                                                                                                                            |         |
| **icon size:>200000 extension:css**]\(<https://github.com/search?utf8=%E2%9C%93&q=icon+size%3A%3E200000+extension%3Acss&type=Code>) coincide con los archivos de más de 200 KB que terminan en .css y tienen la palabra "icon".               |         |

## Información adicional

* [Clasificar resultados de búsqueda](/es/enterprise-server@3.22/search-github/getting-started-with-searching-on-github/sorting-search-results)
* [Buscar en bifurcaciones](/es/enterprise-server@3.22/search-github/searching-on-github/searching-in-forks)