diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..e905f9b Binary files /dev/null and b/.DS_Store differ diff --git "a/es/Parte1-Fundamentos_de_la_l\303\255nea_de_comandos.md" "b/es/Parte1-Fundamentos_de_la_l\303\255nea_de_comandos.md" new file mode 100644 index 0000000..041b8a4 --- /dev/null +++ "b/es/Parte1-Fundamentos_de_la_l\303\255nea_de_comandos.md" @@ -0,0 +1,668 @@ +# Parte1-Fundamentos_de_la_línea_de_comandos.md + +# **Conceptos básicos de la línea de comandos** + +## **¿Qué es la Interfaz de Línea de Comandos?** + +Debajo de la maravillosa Interfaz Gráfica de Usuario ("GUI") de Mac se encuentra un método poderoso y flexible de trabajar directamente con archivos y la web. Esto es conocido como la "interfaz de línea de comandos", o a veces "CLI". + +Puede parecer geek al principio, y su profundidad puede ser intimidante, pero no necesitas aprender todo para que la línea de comandos te sea bastante útil. En particular, para aprender a programar aplicaciones web o clientes de manera efectiva en Mac, necesitarás tener algo de comodidad con los conceptos básicos de la línea de comandos de Mac. + +## **El Terminal, la Consola, el Shell y la Línea de Comandos** + +Primero, deberías aprender cómo iniciar la aplicación incorporada que ejecuta el CLI de Mac, llamada *Terminal*. Para lanzarla, en lugar del método GUI habitual de abrir el directorio Aplicaciones/Utilidades y hacer doble clic en la aplicación Terminal, en cambio, deberías aprender a lanzar el Terminal únicamente utilizando tu teclado. + +Escribe **`command + spacebar`** y luego escribe **`terminal`** y presiona return. De hecho, ni siquiera necesitas escribir la palabra completa, generalmente con las primeras letras **`ter`** o **`term`** es suficiente. + +Cuando el Terminal se abre por primera vez, deberías ver una pequeña ventana con este texto en ella: + +```markdown +Last login: {alguna fecha} on console +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +La ventana que ves es creada por la aplicación *Terminal*, que más correctamente es una forma de *emulador de terminal* y su contenido (cualquier comando y el texto de salida de comandos anteriores) es conocido como *consola*. Estas palabras provienen de los días en que tenías una pantalla CRT verde y un teclado: la máquina en su conjunto era el *terminal*, y el contenido de la pantalla era la *consola*. Nuestro *emulador de terminal* nos proporciona la experiencia de escribir en un antiguo terminal desde la comodidad de nuestro sistema operativo gráfico moderno. + +El texto antes y hasta el $ es conocido como *prompt*. La *línea de comandos* es todo después del prompt actual, y es la parte de la consola donde puedes escribir. + +El símbolo 🁢 es la ubicación de tu *cursor de texto* en la línea de comandos. Todo lo que escribas aparecerá debajo del cursor de texto y el cursor de texto se moverá al siguiente lugar. + +Todo el texto que ves en la consola fue creado por lo que se conoce como la aplicación *shell* (Mac por defecto usa la aplicación shell conocida como *bash*). + +A menudo las palabras terminal, consola, línea de comandos, shell o bash se usan indistintamente, pero cada una de estas son ligeramente diferentes. + +Algún día tal vez quieras cambiar a aplicaciones de Terminal más sofisticadas (*iTerm* es popular), o cambiar a un shell de texto más sofisticado (*tsch* es popular), o ambos. Para el propósito de este tutorial *Intro a la Línea de Comandos* solo estaremos usando la aplicación Mac *Terminal* por defecto, y el shell de línea de comandos de texto *bash*. + +## **Ejecutando un Comando** + +Si ahora escribes el texto **`ls -l ~`** verás el texto aparecer a la derecha del $. Este es tu *comando*. Escribe return para *ejecutar* tu comando. + +```markdown +COMPUTERNAME:~ USERNAME$ ls -l ~ +total 0 +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Desktop +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Documents +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Downloads +drwx------@ 43 USERNAME staff 1462 Apr 12 00:15 Library +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Movies +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Music +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Pictures +drwxr-xr-x+ 5 USERNAME staff 170 Oct 21 18:44 Public +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Casi todos los comandos siguen un patrón común con 3 partes principales. El programa, las opciones y los argumentos, cada uno separado por espacios. + +El programa es el verbo, en este caso la primera parte **`ls`**, que es corto para *listar*, que nos mostrará una lista de archivos. + +Las opciones son como el adverbio, y modifican cómo se ejecuta el programa. Las opciones casi siempre comienzan con un guion. En este ejemplo **`-l`** significa *largo*, así que el comando **`ls`** ahora nos mostrará más información detallada en lugar de solo los nombres de los archivos. + +Los argumentos son lo que queda, y son los objetos de nuestro comando. Describen lo que queremos que nuestro programa actúe. En este caso estamos usando un nombre especial abreviado para nuestro directorio hogar **`~`**. + +Combinados, estas tres partes le dicen al computador listar, en forma larga, el contenido de tu directorio hogar. + +## **El Directorio Actual** + +Cuando ingresas muchos comandos sin ningún argumento, actuarán por defecto en el directorio actual (también conocido como carpeta). ¿Qué es el directorio actual? Escribe **`pwd`**. + +```markdown +COMPUTERNAME:~ USERNAME$ pwd +/Users/USERNAME +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +El comando **`pwd`** es corto para 'present working directory' que básicamente significa "¿Dónde estoy ahora?". El resultado de **`pwd`** es el *camino* a donde cualquier comando sin argumentos actuará por defecto. + +```markdown +COMPUTERNAME:~ USERNAME$ ls +Desktop Downloads Movies Pictures +Documents Library Music Public +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Nota que el comando **`ls`** nos mostró un directorio adicional que no puedes ver desde la GUI de Finder de Mac: el directorio Library. Puede haber otros archivos invisibles. Podemos ver estos agregando al comando **`ls`** una opción, en este caso **`-a`**. Juntos el comando y la opción **`ls -a`** significan 'listar todo'. + +```markdown +COMPUTERNAME:~ USERNAME$ ls +. Desktop Movies +.. Documents Music +.CFUserTextEncoding Downloads Pictures +.Trash Library Public +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +El comando 'ls -a' revela una serie de directorios y archivos que están marcados como invisibles para Finder y la GUI de Mac. Cualquier archivo o directorio que comience con un punto también será invisible para Finder. Aprenderemos más sobre estos archivos más tarde. + +Para mirar el contenido de otro directorio, puedes agregar una opción de *camino* al comando **`ls`**. Escribe **`ls Public`** para ver el contenido de tu directorio Public (el nombre del directorio **`Public`** distingue entre mayúsculas y minúsculas: **`public`** no funcionará). + +```markdown +COMPUTERNAME:~ USERNAME$ ls Public +Drop Box +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +El comando **`ls -l`** (es decir, **`listar largo`**) lista información adicional sobre cada ítem en el directorio actual: + +```markdown +COMPUTERNAME:~ USERNAME$ ls -l +total 0 +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Desktop +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Documents +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Downloads +drwx------@ 43 USERNAME staff 1462 Apr 12 00:15 Library +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Movies +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Music +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Pictures +drwxr-xr-x+ 5 USERNAME staff 170 Oct 21 18:44 Public +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Con la opción **`-l`** la **`d`** a la izquierda te dice que el ítem en el directorio contiene otro directorio. Un guion **`-`** te dice que el ítem es un archivo. + +Puedes combinar opciones, así que **`ls -la`** listará toda la información sobre todo el contenido del directorio actual, incluyendo archivos ocultos con punto **`.`** y directorios invisibles como **`Library`**. + +```markdown +COMPUTERNAME:~ USERNAME$ ls -l +total 8 +drwxr-xr-x+ 14 USERNAME staff 476 Apr 12 12:39 . +drwxr-xr-x 6 root admin 204 Oct 21 18:44 .. +-r-------- 1 USERNAME staff 7 Oct 21 18:46 .CFUserTextEncoding +drwx------ 2 USERNAME staff 68 Apr 11 23:27 .Trash +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Desktop +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Documents +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Downloads +drwx------@ 43 USERNAME staff 1462 Apr 12 00:15 Library +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Movies +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Music +drwx------+ 3 USERNAME staff 102 Oct 21 18:44 Pictures +drwxr-xr-x+ 5 USERNAME staff 170 Oct 21 18:44 Public +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +También puedes agregar el nombre de un directorio como un argumento para ver el contenido de ese directorio, por ejemplo **`ls -la Public`** + +```markdown +COMPUTERNAME:~ USERNAME$ ls -la Public +total 0 +drwxr-xr-x+ 5 ChristopherA staff 170 Oct 21 18:44 . +drwxr-xr-x+ 13 ChristopherA staff 442 Apr 12 12:41 .. +-rw-r--r-- 1 ChristopherA staff 0 Oct 21 18:44 .com.apple.timemachine.supported +-rw-r--r-- 1 ChristopherA staff 0 Oct 21 18:44 .localized +drwx-wx-wx+ 3 ChristopherA staff 102 Oct 21 18:44 Drop Box +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +## **Completación con Tabulador** + +Una característica útil que ofrece la línea de comandos se llama "completación de línea de comandos" o "completación con tabulador". Esto significa que si ingresas información insuficiente sobre un argumento, puedes presionar la tecla **`tab`** para ver cuáles son las opciones, o si solo hay una opción, seleccionar esa. + +Pruébalo escribiendo **`ls M`** luego presiona la tecla **`tab`** en lugar de return. + +```markdown +COMPUTERNAME:~ USERNAME$ ls M→ +Movies/ Music/ +COMPUTERNAME:~ USERNAME$ ls M🁢 +``` + +En este caso hay dos ítems que comienzan con M, por lo que la línea de comandos los lista ambos y retiene el texto que comenzaste. Ahora agrega una letra más, **`o`** y presiona la tecla **`tab`**: + +```markdown +COMPUTERNAME:~ USERNAME$ ls Movies/🁢 +``` + +Solo había un ítem que comenzaba con **`Mo`**, el directorio Movies. Si presionas **`return`** verás el contenido de esa carpeta. + +La completación con tabulador es muy útil para nombres de archivos que tienen espacios en ellos. Por ejemplo: + +```markdown +COMPUTERNAME:~ USERNAME$ls -la Public/Drop Box +ls: Box: No such file or directory +ls: Public/Drop: No such file or directory +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Básicamente, el programa **`ls`** está confundido por el espacio en el nombre del directorio **`Drop Box`**, y piensa que quieres listar los contenidos de **`Drop`** y **`Box`** como argumentos separados. + +Puedes arreglar esto poniendo comillas alrededor del camino y nombre del archivo: + +```markdown +COMPUTERNAME:~ USERNAME$ls -la "Public/Drop Box" +total 0 +drwx-wx-wx+ 3 ChristopherA staff 102 Oct 21 18:44 . +drwxr-xr-x+ 5 ChristopherA staff 170 Oct 21 18:44 .. +-rw-r--r-- 1 ChristopherA staff 0 Oct 21 18:44 .localized +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Alternativamente, puedes arreglar esto "escapando" el espacio poniendo una barra invertida delante, por ejemplo: + +```markdown +COMPUTERNAME:~ USERNAME$ls -la Public/Drop\ Box +total 0 +drwx-wx-wx+ 3 ChristopherA staff 102 Oct 21 18:44 . +drwxr-xr-x+ 5 ChristopherA staff 170 Oct 21 18:44 .. +-rw-r--r-- 1 ChristopherA staff 0 Oct 21 18:44 .localized +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Finalmente, solo escribe **`ls -la Pu`** luego presiona tab, luego escribe **`D`** y presiona tab de nuevo. El camino será autocompletado con todos los espacios correctamente escapados. + +## **Truco del Camino del Finder** + +Un truco para caminos muy largos con espacios y otros caracteres especiales en ellos es que puedes arrastrar el archivo o carpeta desde una ventana del Finder (o el ícono de la carpeta en la barra de título de una ventana del Finder) al prompt, y el camino completo y nombre del archivo serán añadidos a tu línea de comandos. + +Prueba **`ls`** seguido de arrastrar una carpeta abierta en la GUI del Finder, luego presiona **`return`**. + +## **Caminos Absolutos y Directorio Hogar** + +Hasta ahora, hemos listado el contenido de directorios que existen dentro de nuestro directorio actual. Cada directorio en tu computador tiene un nombre y un camino que te lleva a él. + +¿Qué pasa si queremos ver otros directorios? Una forma es por lo que se conoce como el "camino absoluto". Estos caminos comienzan con el carácter **`/`**. + +Pruébalo: + +```markdown +COMPUTERNAME:~ USERNAME$ls / +Applications home +Library installer.failurerequests +System net +Users private +Volumes sbin +bin tmp +dev usr +etc var +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Esto revela ítems en la carpeta "raíz" de tu computadora. Algunos los reconocerás desde la GUI del Finder, otros son invisibles para el Finder. Desde la línea de comandos, el directorio raíz **`/`** es el punto de partida para todo el contenido de tu computadora. Contiene todos los directorios en tu unidad de arranque, directorios para otras unidades, así como una serie de directorios de sistema especiales. + +Ahora miremos el camino absoluto para el Directorio de Usuarios: + +```markdown +COMPUTERNAME:~ USERNAME$ls /Users +USERNAME Shared +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Ahora agreguemos tu nombre de usuario (si tiene un espacio en él, ¡prueba la completación con tabulador!): + +```markdown +COMPUTERNAME:~ USERNAME$ls /Users/USERNAME +Desktop Downloads Movies Pictures +Documents Library Music Public +COMPUTERNAME:~ USERNAME$ 🁢 +``` + +Este es tu directorio de trabajo actual, que también es el directorio "hogar" predeterminado al que la aplicación shell por defecto, por lo que da el mismo resultado exacto que **`ls`** por sí solo. + +Tu directorio hogar **`/Users/USERNAME/`** o **`~`** abreviado, contiene tus archivos y directorios personales. Por ejemplo Pictures, Music, Documents, etc. Cada uno de estos directorios se referencia como /home/USERNAME/{nombre del directorio}. Por ejemplo Documents se encuentra en /home/USERNAME/Documents. + +Este camino hogar será diferente para cada usuario de la máquina, por lo que hay un atajo para él que es diferente para cada usuario, llevándolos a su directorio hogar. Este es el carácter tilde **`~`**. Así que **`ls`**, **`ls /Users/USERNAME/`** y 'ls ~` todos dan el mismo resultado. + +Al igual que con los directorios, los archivos se referencian de la misma manera, por ejemplo, un archivo llamado temp.txt ubicado en el directorio hogar del usuario christophera puede ser referenciado usando el camino completo **`/Users/christophera/temp.txt`** o **`~/temp.txt`** por ese usuario. + +Tanto archivos como directorios pueden ser referenciados usando sus caminos absolutos desde cualquier lugar en el sistema. Adicionalmente, se puede acceder a ellos usando solo su nombre si están en el mismo directorio. Por ejemplo, si tu directorio de trabajo actual es **`~`** cuando usas el terminal, puedes acceder al archivo **`/Users/USERNAME/temp.txt`** ingresando solo **`temp.txt`**. + +## **Cambiando el Directorio de Trabajo** + +En todos los ejemplos anteriores, nuestro camino del directorio de trabajo actual era el directorio hogar. Para cambiar el directorio de trabajo actual, escribe **`cd`** seguido por el {camino del directorio}, por ejemplo: + +```markdown +COMPUTERNAME:~ USERNAME$cd Desktop +COMPUTERNAME:Desktop USERNAME$ 🁢 +``` + +Nota que tu prompt ahora muestra tu directorio de trabajo. Para ver el "camino absoluto" de ese directorio, escribe **`pwd`** nuevamente. + +```markdown +COMPUTERNAME:Desktop USERNAME$ pwd +/Users/USERNAME/Desktop +COMPUTERNAME:Desktop USERNAME$ 🁢 +``` + +Para volver a tu directorio hogar, puedes escribir **`cd`** sin opciones ni argumentos, pero prefiero escribir **`cd ~`** para recordarme que estoy regresando a casa. + +## **Creando un Directorio Temporal** + +En la mayoría de los ejemplos restantes ya no voy a demostrar el prompt completo. En cambio, cuando veas el primer **`$`** muestra dónde debes escribir a la derecha de ese prompt. Un **`$`** final sin texto muestra que la salida de tu comando ha completado. + +A medida que no queremos llenar nuestro directorio hogar con muchos archivos, vamos a crear un directorio **`temp`** para mantener nuestro trabajo futuro. Usaremos el comando **`mkdir`** (*hacer directorio*), luego entrar al folder con el comando **`cd`**, y confirmar que estamos ahí con el comando **`pwd`**. + +```markdown +$ cd ~ +$ mkdir temp +$ cd temp +$ pwd +/Users/USERNAME/temp +$ +``` + +## **Manipulando Archivos** + +Para crear tu primer archivo vacío, usa el comando **`touch`** seguido por el nombre del archivo: + +```markdown +$ touch temp.txt +$ +``` + +Puedes ver que este archivo existe con el comando **`ls`**: + +```markdown +$ ls +temp.txt +$ +``` + +Puedes editar este archivo de texto con tu editor de texto GUI de Mac (por defecto la app *Text Edit* en tu carpeta *Aplicaciones*) usando el comando **`open`**. + +```markdown +$ open temp.txt +$ + +``` + +Ingresa algún texto en ese archivo, guárdalo (usa **`command + S`**) y ciérralo (usa **`command + W`**). Luego vuelve al terminal usando **`command + tab`** para alternar entre tus apps, o **`command + space + term`**. Cuando usas la línea de comandos de Mac es importante aprender estas teclas de comando: tus manos raramente necesitan dejar el teclado. + +Ahora podemos mostrar ese texto usando el comando **`cat`** (cuyo nombre es corto para *concatenate*). + +```markdown +$ cat temp.txt +The quick brown fox jumped over the lazy dog. +$ +``` + +Si hubiera muchas páginas de texto, también puedes usar el comando **`more`**, que si hay más de una ventana de texto mostrará una ventana llena a la vez. Solo escribe **`space`** para ver la siguiente ventana, o **`q`** para salir, o **`h`** para ver una lista de otras opciones. + +Ahora podemos copiar ese archivo usando el comando **`cp`** (*copiar*). + +```markdown +$ cp temp.txt temporary.txt +$ cat temporary.txt +The quick brown fox jumped over the lazy dog. +$ ls +temp.txt temporary.txt +$ +``` + +Podemos copiar ese archivo a otro directorio también, agregando el camino. En este caso copiaremos un archivo temporal al directorio hogar. + +```markdown +$ cp temp.txt ~/temp.txt +$ ls ~/*.txt +temp.txt +$ +``` + +Podemos renombrar un archivo usando el comando **`mv`** (*mover*). + +```markdown +$ mv temp.txt temp.bak +$ ls +temp.bak temporary.txt +$ +``` + +También podemos mover un archivo con el mismo comando. + +```markdown +$ ls +temp.bak temporary.txt +$ ls ~/*.txt +temp.txt +$ mv ~/temp.txt ./temp.txt +$ ls +temp.bak temp.txt temporary.txt +$ ls ~/*.txt +$ +``` + +Podemos eliminar todos estos archivos usando el comando **`rm`** (corto para *eliminar*). Dado que **`rm`** puede ser peligroso, siempre recomiendo usarlo con la opción **`-i`** que lo hace interactivo. + +```markdown +$ rm -i temp.txt +remove temp.txt? y +$ rm -i temporary.txt +remove temporary.txt? y +$ rm -i temp.bak +remove temp.bak? y +$ +``` + +## **Los dos puntos (..) y el punto (.) Caminos Relativos** + +Hay dos caminos especiales, el **`.`** y '..` - estos se usan para lo que son caminos *relativos*. + +El directorio **`..`** es el directorio *arriba* del directorio de trabajo actual. Así que mientras aún estés en el directorio **`~/temp`** escribes 'ls ..` y verás el contenido del directorio hogar: + +```markdown +$ ls .. +Desktop Downloads Movies Pictures +Documents Library Music Public +$ +``` + +Mientras estés en ~/temp también puedes ingresar **`ls ..\{nombre del directorio}`** para ver directorios hermanos bajo el directorio hogar. + +Si estuvieras profundamente dentro de un conjunto complejo de directorios, puedes salir de ellos ingresando **`cd ..`** - nota cómo cambia el prompt después de cada comando: + +```markdown +COMPUTERNAME:~ temp USERNAME$ pwd +/Users/ChristopherA/temp +COMPUTERNAME:~ temp USERNAME$ cd .. +COMPUTERNAME:~ USERNAME$ cd .. +COMPUTERNAME:Users USERNAME$ cd .. +COMPUTERNAME:/ USERNAME$ cd ~/temp +COMPUTERNAME:temp USERNAME$ pwd +/Users/USERNAME/temp +COMPUTERNAME:~ USERNAME$ +``` + +Un camino que comienza con **`.`** significa relativo al directorio de trabajo actual. En efecto **`ls .`** es lo mismo que **`ls`**. Hay momentos en que absolutamente quieres que un camino sea relativo a donde estás actualmente, usa la forma **`.`**. + +## **Los * y ? Comodines** + +A veces quieres copiar, renombrar o eliminar múltiples archivos a la vez. Podemos hacer esto usando el caracter comodín **`*`** (a veces llamado *estrella*) para reemplazar cero o más caracteres en un nombre de archivo o directorio. + +El comando **`rm *`** eliminará todo en el directorio de trabajo actual excepto por aquellos archivos que son especiales y comienzan con un **`.`**, por lo tanto, hasta que seas muy experimentado, recomiendo que siempre uses la opción **`-i`** (para *interactivo*) cuando uses **`rm`**. + +Prueba este experimento: + +```markdown +$ cd ~/temp +$ ls +$ ls -a +. .. +$ mkdir there +$ touch .where here that then +$ ls +here that then there +$ ls -a +. .. .where here that then there +$ rm -i t* +remove that? y +remove then? y +rm: there: is a directory +$ ls +here there +$ ls -a +. .. .where here there +$ rm -i * +remove here? y +rm: there: is a directory +$ ls +there +$ ls -a +. .. .where there +$ rm -i .w* +remove .where? y +$ rm -i .* +rm: "." and ".." may not be removed +$ +``` + +Como puedes ver, intentar eliminar directorios, incluyendo el **`.`** (el directorio actual) y **`..`** (el directorio padre) no está permitido con el comando **`rm -i`**. Entonces, ¿cómo eliminas directorios? Con el comando **`rmdir`**. + +```markdown +$ ls +there +$ rmdir there +$ ls +$ +``` + +Este comando puede parecer peligroso, pero el comando **`rmdir`** tiene una protección que no te permite eliminar carpetas que tienen contenidos. Primero debes eliminar cualquier contenido. + +```markdown +$ mkdir there +$ touch there/that +$ ls there +that +A$ rmdir there +rmdir: there: Directory not empty +$ rm -i there/* +remove there/that? y +$ rmdir there +$ ls +$ +``` + +Un uso particularmente común del comodín **`*`** es para ver o eliminar solo archivos con ciertas extensiones. Por ejemplo: + +```markdown +$ touch a.txt b.txt a.jpg b.jpg +$ ls a* +a.jpg a.txt +$ ls a.* +a.jpg a.txt +$ ls *.txt +a.txt b.txt +$ rm -i a.* +remove a.jpg? y +remove a.txt? y +$ ls +b.jpg b.txt +$ rm -i *.txt +remove b.txt? y +$ ls +b.jpg +$ rm -i *.* +remove b.jpg? y +$ ls +$ +``` + +Supongamos que tienes algunos archivos que terminan en **`.jpg`** y algunos que terminan en **`.jpeg`** -- el comodín asterisco facilita la limpieza: + +```markdown +$ touch a.jpg b.jpeg c.java d.js +$ rm -i *.jp*g +remove a.jpg? y +remove b.jpeg? y +$ rm -i *.j* +remove c.java? y +remove d.js? y +$ ls +$ +``` + +El comodín **`*`** coincide con cero o más caracteres, pero a veces puedes querer coincidir solo con un caracter. En este caso usamos el comodín **`?`**: + +```markdown +$ touch task taskA taskB taskXY +$ ls task* +task taskA taskB taskXY +$ ls task? +taskA taskB +$ ls task?? +taskXY +$ rm -i ?ask* +remove task? y +remove taskA? y +remove taskB? y +remove taskXY? y +$ ls +$ +``` + +Así que ahora que hemos terminado con nuestro directorio temp, podemos eliminar el directorio completo y todo su contenido de una vez con el comando **`rm -ir`** y la opción: + +```markdown +$ cd .. +$ pwd +/Users/USERNAME +$ ls temp +task taskA taskB taskXY +$ rm -ir temp +examine files in directory temp? y +remove temp/task? y +remove temp/taskA? y +remove temp/taskB? y +remove temp/taskXY? y +remove temp? y +$ +``` + +## **Obteniendo Ayuda** + +Si no recuerdas qué hace un comando, hay un comando **`whatis`** que devuelve una línea básica de información sobre él. También puedes usarlo para buscar palabras completas en la descripción de comandos: + +```markdown +$ whatis cat +cat(1) - concatenate and print files +$ whatis rm +rm(1), unlink(1) - remove directory entries +$ whatis delete +at(1), batch(1), atq(1), atrm(1) - queue, examine, or delete jobs for later execution +delete(n) - delete things in the interpreter +ldapdelete(1) - LDAP delete entry tool +rename(ntcl) - Rename or delete a command +unset(ntcl) - Delete variables +$ +``` + +Relacionado está **`apropos`** que te permite buscar palabras clave. Típicamente devolverá muchos más ítems que **`whatis`**. + +```markdown +$ whatis unzip +unzip(1) - list, test and extract compressed files in a ZIP archive +$ apropos unzip +bzip2(1), bunzip2(1) - a block-sorting file compressor, v1.0.6 bzcat - decompresses files to stdout bzip2recover - recovers data from damaged bzip2 files +funzip(1) - filter for extracting from a ZIP archive in a pipe +unzip(1) - list, test and extract compressed files in a ZIP archive +unzipsfx(1) - self-extracting stub for prepending to ZIP archives +$ +``` + +Cada uno de estos comandos tienen archivos de ayuda asociados con ellos, que pueden ser vistos con el comando **`man`** (corto para *manual*). + +Al igual que el comando **`more`**, teclear **`space`** mueve hacia abajo una ventana llena de texto, y teclear **`q`** saldrá. Incluso puedes ver la página man de man con **`man man`**. + +Muchos, pero no todos los comandos te darán un breve resumen de lo que hacen si los escribes sin opciones, o con la opción **`-h`** o **`--help`**. Muchas opciones pueden ser crípticas, pero la página man de los comandos debería explicarlas en más detalle. + +## **MacOSX Bash Shell Keys** + +### **Las siguientes funcionan en todas partes** + +```markdown +Command-Shift-3 Capture the screen to a file +Command-Shift-Control-3 Capture the screen to the Clipboard +Command-Shift-4 Capture a selection of the screen to a file, or press the spacebar to capture just a window +Command-Shift-Control-4 Capture a selection of the screen to the Clipboard, , or press the spacebar to capture just a window +``` + +### **Las siguientes teclas funcionan en la mayoría de las apps de Mac donde se admite la entrada de texto:** + +```markdown +Cmd + A Select all text in text area +Ctrl + A Move cursor to the beginning of the line or paragraph you are currently typing on +Ctrl + B Move the cursor one character backward (same as Left-Arrow) +Ctrl + D Delete one character in front of cursor (same as fn-Delete) +Ctrl + E Move cursor to the end of the line you are currently typing on +Ctrl + F Move the text cursor one character forward (same as Right-Arrow) +Ctrl + H Delete the character behind the curor +Ctrl + K Delete "Kills" all characters after cursor to the end of the line. +Ctrl + N Move the cursor down one line (same as Down-Arrow) +Ctrl + P Move the cursor up one line (same as Up-Arrow) +Ctrl + T Swap the last two characters before the cursor +Ctrl + Y Pastes "Yanks" text that was Killed (Ctrl+K) +``` + +### **Las siguientes solo funcionan en la Terminal de Mac OSX usando el shell Bash predeterminado:** + +```markdown +Ctrl + C Kill whatever you are running +Ctrl + D Exit the current shell +Ctrl + G Aborts the current incremental search, restoring the original command at the prompt +Ctrl + J Stops incremental search (Ctrl-R or Ctrl-S) and puts the found command at the prompt +Ctrl + L Clears the the terminal window, leaving the current command at the prompt, similar to the clear command +Ctrl + R Incrementally searches back through previously used commands (with history or !) +Ctrl + S Incrementally searches forward through previously used commands (with history or !) +Ctrl + U Clears the line before the cursor position. If you are at the end of the line, clears the entire line. +Ctrl + W Delete the word before the cursor +Ctrl + Z Puts whatever you are running into a suspended background process. fg restores it. +Ctrl + _ Undo the last editing command; you can undo all the way back to an empty line +Esc + B Move cursor backward one word on the current line +Esc + D Delete one word in front of cursor +Esc + F Move cursor forward one word on the current line +Esc + R Undo all changes made to this line +Esc + T Swap the last two words before the cursor +Esc + Y Pastes "Yanks" text that was previous Killed (Ctrl+K) before the last Kill +Tab Auto-complete files and folder names +Tab Tab Display all possible auto-complete values +``` + +### **Ratón en la Terminal** + +```markdown +Opt + Click Moves cursor to where the mouse was clicked in many shell editors. +``` + +## **Comandos Meta** + +``! - inicia una sustitución de historial !n - el comando en la lista de historial de bash, para algún entero n (funciona para negativos también) !! - el comando anterior; equivalente a !-1 +!string - el comando más reciente que comienza con string + +Los designadores de palabra seleccionan ciertas partes de un evento. Usa : para separar el evento del designador de palabra. Las palabras están numeradas desde 0 comenzando al inicio de la línea, y se insertan en la línea actual separadas por espacios simples. + +$ - designa el último argumento (por ejemplo, !!:$ es el último arg del último comando; se puede acortar a !$) n - designa la enésima palabra (por ejemplo, !str:2 es el 2do arg del comando más reciente que comienza con str; !!:0 es el comando del último comando) \ No newline at end of file diff --git a/es/Parte2-Preparacion_e_instalacion.md b/es/Parte2-Preparacion_e_instalacion.md new file mode 100644 index 0000000..f555b3d --- /dev/null +++ b/es/Parte2-Preparacion_e_instalacion.md @@ -0,0 +1,370 @@ +# Parte2-Preparación_e_instalación.md + +Cada Mac soporta un gran número de herramientas de línea de comandos, sin embargo, no todos los programas que necesitas para el desarrollo web están incluidos por defecto. Este tutorial te instruye sobre cómo preparar y configurar tu Mac para convertirlo en un potente sistema de desarrollo web. + +No necesitas entender profundamente todos los comandos que se usan aquí — se explican brevemente, pero aún no necesitas aprenderlos. Solo los explico porque es TU computadora y deberías saber qué herramientas se han añadido y por qué. + +## **Actualizaciones del Sistema** + +Lo primero que necesitas hacer es asegurarte de que tienes la versión más reciente del sistema operativo, que al momento de escribir esta introducción es Mac OS X Yosemite 10.10.3. Todo en estos archivos de introducción debería funcionar en versiones anteriores del sistema operativo, sin embargo, cuando estás desarrollando web es importante tener las actualizaciones más recientes por razones de seguridad. + +Puedes obtener todas tus actualizaciones del sistema yendo al ítem *App Store…* bajo el menú Apple, haciendo clic en la pestaña *Updates* y presionando el botón *Update All*. Sin embargo, también puedes hacerlo desde la línea de comandos. + +El comando **`sudo`** se usa para ejecutar programas que necesitan privilegios adicionales para cambiar tu computadora, y por lo tanto, la contraseña administrativa de tu Mac. **`/usr/sbin/softwareupdate -l`** es el programa que verifica con los servidores de actualización de Apple la versión más reciente. Puede que necesites ejecutar este comando varias veces, o incluso reiniciar tu sistema si tu Mac no está actualizado. + +```markdown +$ cd ~ +$ sudo /usr/sbin/softwareupdate -l + +WARNING: Improper use of the sudo command could lead to data loss +or the deletion of important system files. Please double-check your +typing when using sudo. Type "man sudo" for more information. + +To proceed, enter your password, or type Ctrl-C to abort. + +Password: +Software Update Tool +Copyright 2002-2012 Apple Inc. + +Finding available software +No new software available. +$ +``` + +## **Instalar las Herramientas de Línea de Comandos de Apple** + +A continuación, vamos a instalar las Herramientas de Línea de Comandos de Apple, que instalarán una serie de herramientas de desarrollo que estarán disponibles desde la línea de comandos. Hay un "truco" que consiste en tocar un archivo que hace que esto suceda desde la línea de comandos sin cargar el entorno de desarrollo XCODE de Apple para crear aplicaciones para Mac y iOS. + +Debido a que recientemente ingresaste una contraseña administrativa para el comando **`sudo`**, es posible que el shell no te pida de nuevo tu contraseña administrativa. + +```markdown +$ touch /tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress +sudo /usr/sbin/softwareupdate -ia +Software Update Tool +Copyright 2002-2012 Apple Inc. + +Finding available software + +Downloading Command Line Tools (OS X 10.10) +Downloaded Command Line Tools (OS X 10.10) +Installing Command Line Tools (OS X 10.10) +Done with Command Line Tools (OS X 10.10) +Done. +$/bin/rm /tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress +``` + +Con esta instalación, acabas de instalar 92 herramientas de desarrollo en tu /Library/Developer/CommandLineTools/bin/ + +```markdown +BuildStrings CpMac DeRez GetFileInfo MergePef MvMac ResMerger Rez RezDet RezWack SetFile SplitForks UnRezWack ar as asa bison c++ c89 c99 cc clang clang++ cmpdylib codesign_allocate cpp ctags ctf_insert dsymutil dwarfdump dyldinfo flex flex++ g++ gatherheaderdoc gcc gcov git git-cvsserver git-receive-pack git-shell git-upload-archive git-upload-pack gm4 gnumake gperf hdxml2manxml headerdoc2html indent install_name_tool ld lex libtool lipo lldb llvm-cov llvm-profdata lorder m4 make mig mkdep nasm ndisasm nm nmedit otool pagestuff projectInfo ranlib rebase redo_prebinding resolveLinks rpcgen segedit size strings strip svn svnadmin svndumpfilter svnlook svnrdump svnserve svnsync svnversion unifdef unifdefall unwinddump what xml2man yacc +``` + +A partir de ahora, la actualización regular del Sistema de la Mac App Store mantendrá estas herramientas actualizadas. + +## **Crear Algunas Carpetas Adicionales en el Hogar** + +Encuentro útil preparar con antelación algunas carpetas adicionales en mi directorio de inicio "~". La convención que uso es que si la carpeta comienza con una mayúscula, la carpeta contiene elementos para la GUI del Finder. Si la carpeta comienza con una letra minúscula (lo que hace que sea más rápido de escribir) entonces se usa por la CLI. + +Todas estas carpetas son opcionales — muchas no las usarás hasta mucho más tarde en este tutorial: + +- ~/.dotfiles # Aquí es donde respaldo mis dotfiles (explicado más adelante) y almaceno algunas otras herramientas útiles. +- ~/.dotfiles/bin # Aquí es donde guardo pequeños scripts de línea de comandos que uso regularmente. +- ~/Applications # Aquí es donde guardo cualquier aplicación GUI que está instalada para fines de desarrollo separado de esa carpeta de /Applications raíz. +- ~/code # Aquí es donde almaceno el código fuente de repositorios de código abierto de github. +- ~/Pool # Aquí es donde almaceno archivos grandes que excluyo de la copia de seguridad en Time Machine. Genial para películas, archivos grandes de instalación, etc., que tengo respaldados en otro lugar o que se pueden descargar nuevamente de la red. +- ~/projects # Aquí es donde guardo repositorios de mi propio código fuente o trabajos en progreso de otros. +- ~/temp # Aquí es donde guardo código y proyectos que son solo temporales y pueden ser eliminados en cualquier momento. Practico aquí. + +```markdown +$ mkdir ~/.dotfiles ~/.dotfiles/bin ~/Applications ~/code ~/Pool ~/projects ~/temp +$ ls -a +. Desktop Pictures +.. Documents Pool +.CFUserTextEncoding Downloads Public +.Trash Library code +.dotfiles Movies projects +Applications Music temp + +$ +``` + +## **Instalación de Brew** + +A continuación, vamos a instalar [Homebrew](http://brew.sh/) (conocido como **`brew`**), un gestor de paquetes de software. + +Puedes considerar **`brew`** como una tienda de aplicaciones para aplicaciones web de código abierto y herramientas de desarrolladores. Hay miles de diferentes bases de código abierto, todas con varias dependencias entre ellas, y cada una requiriendo diferentes configuraciones según el sistema operativo de computadora en el que se ejecuta (Linux, Unix, Mac, Windows, etc.). Brew gestiona esas complejidades. Si solicitas instalar una herramienta particular que necesita otros paquetes, herramientas o bibliotecas para funcionar, Brew primero los instalará en el orden correcto. Brew también almacena sus archivos de algunas maneras específicas que son las mejores prácticas para que diferentes herramientas no interfieran entre sí. + +Brew no está instalado en tu Mac por defecto, por lo que necesitarás ejecutar un script para instalarlo. Proporcionan un script para instalarlo en su sitio de github, que se ejecuta por **`ruby`** que está instalado en tu Mac por defecto. ADVERTENCIA: Ten cuidado siempre que alguien te pida que ejecutes un script que tenga un comando **`curl`** en él, porque si el autor tiene malas intenciones, pueden corromper tu sistema o hacerlo vulnerable. En este caso, el script se ejecuta desde un sitio web confiable (github) y es de una cuenta confiable allí (Homebrew). Te sugiero que vayas al sitio web de [Homebrew](http://brew.sh/) y confirmes que este es el script correcto para usar. + +Este script puede pedirte tu contraseña de administrador. + +```markdown +$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" +==> This script will install: +/usr/local/bin/brew +/usr/local/share/doc/homebrew +/usr/local/share/man/man1/brew.1 +/usr/local/share/zsh/site-functions/_brew +/usr/local/etc/bash_completion.d/brew +/usr/local/Homebrew +==> The following new directories will be created: +/usr/local/Cellar +/usr/local/Homebrew +/usr/local/Frameworks +/usr/local/bin +/usr/local/etc +/usr/local/include +/usr/local/lib +/usr/local/opt +/usr/local/sbin +/usr/local/share +/usr/local/share/zsh +/usr/local/share/zsh/site-functions +/usr/local/var + +Press RETURN to continue or any other key to abort +==> /usr/bin/sudo /bin/mkdir -p /usr/local/Cellar /usr/local/Homebrew /usr/local/Frameworks /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/opt /usr/local/sbin /usr/local/share /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var +==> /usr/bin/sudo /bin/chmod g+rwx /usr/local/Cellar /usr/local/Homebrew /usr/local/Frameworks /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/opt /usr/local/sbin /usr/local/share /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var +==> /usr/bin/sudo /bin/chmod u+rwx share/zsh share/zsh/site-functions +==> /usr/bin/sudo /usr/sbin/chown admin /usr/local/Cellar /usr/local/Homebrew /usr/local/Frameworks /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/opt /usr/local/sbin /usr/local/share /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var +==> /usr/bin/sudo /usr/bin/chgrp admin /usr/local/Cellar /usr/local/Homebrew /usr/local/Frameworks /usr/local/bin /usr/local/etc /usr/local/include /usr/local/lib /usr/local/opt /usr/local/sbin /usr/local/share /usr/local/share/zsh /usr/local/share/zsh/site-functions /usr/local/var +==> /usr/bin/sudo /bin/mkdir -p /Users/admin/Library/Caches/Homebrew +==> /usr/bin/sudo /bin/chmod g+rwx /Users/admin/Library/Caches/Homebrew +==> /usr/bin/sudo /usr/sbin/chown admin /Users/admin/Library/Caches/Homebrew +==> Downloading and installing Homebrew... +remote: Counting objects: 1033, done. +remote: Compressing objects: 100% (929/929), done. +remote: Total 1033 (delta 95), reused 592 (delta 68), pack-reused 0 +Receiving objects: 100% (1033/1033), 1.05 MiB | 508.00 KiB/s, done. +Resolving deltas: 100% (95/95), done. +From https://github.com/Homebrew/brew + * [new branch] master -> origin/master +HEAD is now at 23efbc5 Merge pull request #1051 from woodruffw/cctools-macho-remove +==> Homebrew has enabled anonymous aggregate user behaviour analytics +Read the analytics documentation (and how to opt-out) here: + https://git.io/brew-analytics +==> Tapping homebrew/core +Cloning into '/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core'... +remote: Counting objects: 3725, done. +remote: Compressing objects: 100% (3617/3617), done. +remote: Total 3725 (delta 15), reused 1247 (delta 0), pack-reused 0 +Receiving objects: 100% (3725/3725), 2.91 MiB | 1.13 MiB/s, done. +Resolving deltas: 100% (15/15), done. +Checking connectivity... done. +Tapped 3604 formulae (3,752 files, 9M) +Checking out v1.0.1 in /usr/local/Homebrew... +To checkout master in /usr/local/Homebrew run: + 'cd /usr/local/Homebrew && git checkout master +Already up-to-date. +==> Installation successful! +==> Next steps +Run `brew help` to get started +Further documentation: https://git.io/brew-docs +==> Homebrew has enabled anonymous aggregate user behaviour analytics +Read the analytics documentation (and how to opt-out) here: + https://git.io/brew-analytics +$ +``` + +Después de instalar Homebrew, lo primero que queremos hacer es confirmar que se ha instalado correctamente, o si había algo más instalado en tu Mac anteriormente que podría causar problemas. + +```markdown +$ brew doctor +Your system is ready to brew. +$ +``` + +Si hubiera algún error, **`brew doctor`** te dirá cómo solucionarlo. Si lo que sugiere para solucionar el problema no funciona, encuentro que casi todos los problemas que han surgido son una pregunta en el sitio web [StackOverflow](http://stackoverflow.com/) así que busca tu solución allí. + +## **Instalar Git** + +La primera aplicación de línea de comandos que instalaremos es [Git](http://git-scm.com/), que es el sistema de control de versiones de código fuente más popular. Un sistema de control de código fuente te ayuda a manejar la producción de tu código, hacer copias de seguridad y restaurar diferentes versiones de tu código, y trabajar cooperativamente con otros. **`git`** es popular porque es de código abierto, es distribuido (es decir, no hay un repositorio maestro de donde los archivos deben venir), funciona con proyectos tan grandes como el sistema operativo Linux con miles de colaboradores, proyectos de equipos pequeños, y sin embargo es útil incluso para un solo programador. + +Usaremos **`brew`** para instalar git, así que siempre antes de que hagamos algo con **`brew`** queremos asegurarnos de que **`brew`** está actualizado. Acabamos de instalarlo así que realmente no necesitamos hacer esto ahora, pero demostraré las mejores prácticas (todo después de un # es un comentario): + +```markdown +$ brew doctor # run self test to see if brew is running properly +Your system is ready to brew. +$ brew update # update brew itself to the latest version, and get latest list of apps +Already up-to-date. +$ brew upgrade # upgrade any apps managed by brew to the most recent version +$ + +``` + +A continuación, confirmaremos información sobre git, luego lo instalaremos. + +```markdown +$ brew info git +git: stable 2.3.5 (bottled), HEAD +http://git-scm.com +/usr/local/Cellar/git/2.3.5 (1363 files, 31M) * +Not installed +From: https://github.com/Homebrew/homebrew/blob/master/Library/Formula/git.rb +$ brew install git +==> Downloading https://homebrew.bintray.com/bottles/git-2.3.5.yosemite.bottle.t +######################################################################## 100.0% +==> Pouring git-2.3.5.yosemite.bottle.tar.gz +==> Caveats +The OS X keychain credential helper has been installed to: + /usr/local/bin/git-credential-osxkeychain + +The "contrib" directory has been installed to: + /usr/local/share/git-core/contrib + +Bash completion has been installed to: + /usr/local/etc/bash_completion.d + +zsh completion has been installed to: + /usr/local/share/zsh/site-functions +==> Summary +🍺 /usr/local/Cellar/git/2.3.5: 1363 files, 31M +$ git --version +git version 2.3.5 +$ +``` + +## **Instalar Cask** + +[Cask](http://caskroom.io/) es una aplicación especial de brew que instala una serie de aplicaciones GUI para Mac. La encuentro particularmente útil para instalar esas aplicaciones de desarrolladores que requieren un instalador o un archivo .dmg. Otra cosa útil que hace es que pone la aplicación en tu carpeta ~/Applications, manteniéndolas separadas de tus otras aplicaciones. + +```markdown +$ brew tap caskroom/cask +Checking out v1.0.1 in /usr/local/Homebrew... +To checkout v1.0.1 in /usr/local/Homebrew run: + 'cd /usr/local/Homebrew && git checkout v1.0.1 +==> Tapping caskroom/cask +Cloning into '/usr/local/Homebrew/Library/Taps/caskroom/homebrew-cask'... +remote: Counting objects: 3431, done. +remote: Compressing objects: 100% (3412/3412), done. +remote: Total 3431 (delta 37), reused 452 (delta 13), pack-reused 0 +Receiving objects: 100% (3431/3431), 1.16 MiB | 0 bytes/s, done. +Resolving deltas: 100% (37/37), done. +Checking connectivity... done. +Tapped 0 formulae (3,438 files, 3.6M) +$ +``` + +## **Instalando el Editor de Texto Atom** + +A continuación, vamos a usar **`brew cask`** para instalar el editor de texto Atom. Hay muchos editores de texto de línea de comandos poderosos por ahí (y una batalla constante entre los fans de emacs vs los de vim), pero aprenderlos está fuera del alcance de este tutorial. Mientras tanto, hay un editor de texto GUI muy poderoso, gratuito y de código abierto optimizado para desarrolladores de línea de comandos y web llamado Atom. Una de sus mejores características es su integración con Git. + +Lo instalaremos con **`brew cask`** + +```markdown +$ brew cask install atom +==> We need to make Caskroom for the first time at /opt/homebrew-cask/Caskroom +==> We'll set permissions properly so we won't need sudo in the future +Password: +chmod: /opt: No such file or directory +==> Downloading https://atom.io/download/mac +######################################################################## 100.0% +==> Symlinking App 'Atom.app' to '/Users/ChristopherA/Applications/Atom.app' +==> Symlinking Binary 'apm' to '/usr/local/bin/apm' +==> Symlinking Binary 'atom.sh' to '/usr/local/bin/atom' +🍺 atom staged at '/opt/homebrew-cask/Caskroom/atom/latest' (11288 files, 239M) +$ +``` + +De ahora en adelante, en lugar de usar el comando **`open`** para editar un archivo de texto, usaremos **`atom`**, por ejemplo: + +```markdown +$ touch ~/temp/temp.txt +$ atom ~/temp/temp.txt +``` + +Ahora puedes editar este archivo usando la experiencia GUI familiar de Mac. + +## **Instalar Node** + +[Node](https://nodejs.org/) es una herramienta popular de servidor web que ejecuta Javascript. Instalado en Mac, también proporciona un entorno interactivo para aprender cómo codificar Javascript y usar varios frameworks. Lo estamos instalando porque varios tutoriales más adelante lo usan. + +```markdown +$ brew install node +==> Downloading https://homebrew.bintray.com/bottles/node-0.12.2_1.yosemite.bott +######################################################################## 100.0% +==> Pouring node-0.12.2_1.yosemite.bottle.tar.gz +==> Caveats +If you update npm itself, do NOT use the npm update command. +The upstream-recommended way to update npm is: + npm install -g npm@latest + +Bash completion has been installed to: + /usr/local/etc/bash_completion.d +==> Summary +🍺 /usr/local/Cellar/node/0.12.2_1: 2603 files, 28M +$ +``` + +## **Web Get** + +Encuentro la herramienta **`wget`** muy útil. Apúntala a una URL y descarga los contenidos en un archivo. También puedes hacer esto con la herramienta integrada **`curl`**, pero encuentro **`wget`** muy útil en algunos momentos. + +```markdown +$ brew install wget +==> Installing wget dependency: openssl +==> Downloading https://homebrew.bintray.com/bottles/openssl-1.0.2a-1.yosemite.bottle.tar.gz +######################################################################## 100.0% +==> Pouring openssl-1.0.2a-1.yosemite.bottle.tar.gz +==> Caveats +A CA file has been bootstrapped using certificates from the system +keychain. To add additional certificates, place .pem files in + /usr/local/etc/openssl/certs + +and run + /usr/local/opt/openssl/bin/c_rehash + +This formula is keg-only, which means it was not symlinked into /usr/local. + +Mac OS X already provides this software and installing another version in +parallel can cause all kinds of trouble. + +Apple has deprecated use of OpenSSL in favor of its own TLS and crypto libraries + +Generally there are no consequences of this for you. If you build your +own software and it requires this formula, you'll need to add to your +build variables: + + LDFLAGS: -L/usr/local/opt/openssl/lib + CPPFLAGS: -I/usr/local/opt/openssl/include + +==> Downloading https://www.geotrust.com/resources/root_certificates/certificates/Equifax_Secure_ +######################################################################## 100.0% +==> /usr/local/Cellar/openssl/1.0.2a-1/bin/c_rehash +==> Summary +🍺 /usr/local/Cellar/openssl/1.0.2a-1: 463 files, 18M +==> Installing wget +==> Downloading https://homebrew.bintray.com/bottles/wget-1.16.3.yosemite.bottle.tar.gz +######################################################################## 100.0% +==> Pouring wget-1.16.3.yosemite.bottle.tar.gz +🍺 /usr/local/Cellar/wget/1.16.3: 9 files, 1.5M +Aeguss-MacBook-Pro:intro-mac-command-line ChristopherA$ +``` + +## **Limpieza de Brew & Cask** + +Después de que **`brew`** o **`brew cask`** algo, es una buena práctica decirle a brew que limpie. No tienes que hacer esto después de cada ítem brew, puedes brew varios ítems a la vez y solo limpiar después. + +```markdown +$ brew linkapps --local +Finished linking. Find the links under /Users/ChristopherA/Applications. +$ brew cleanup +$ brew prune +Pruned 0 dead formulae +$ brew cask cleanup +brew cask cleanup +==> Removing dead symlinks +Nothing to do +==> Removing cached downloads +/Library/Caches/Homebrew/atom-latest +/Library/Caches/Homebrew/Casks/atom-latest +$ +``` + +## **Limpieza Final** + +Las bases de datos locate y whathis, usadas por las utilidades de línea de comandos **`locate`**, **`whatis`** y **`apropos`**, solo se generan semanalmente, así que ejecuta esto después de agregar cualquier comando para actualizar la base de datos. Esto sucederá en segundo plano y puede tomar algún tiempo generarse la primera vez. + +```markdown +$ sudo periodic daily weekly monthly +``` \ No newline at end of file diff --git a/es/Parte3-Personaliza_tu_entorno.md b/es/Parte3-Personaliza_tu_entorno.md new file mode 100644 index 0000000..09dc648 --- /dev/null +++ b/es/Parte3-Personaliza_tu_entorno.md @@ -0,0 +1,182 @@ +# Parte3-Personaliza_tu_entorno.md + +Esta parte es completamente opcional. Aquí tengo una serie de recomendaciones sobre cómo personalizar tu "entorno" de línea de comandos para que sea un poco más fácil de usar. No hay nada aquí que sea necesario para más adelante. + +## **Perfiles de Terminal Solarizados** + +La aplicación *Terminal* te permite elegir entre varias opciones para cómo se muestra la ventana del terminal. Abre su menú *Terminal*, submenú *Preferencias* y se pueden definir varias opciones. Haz clic en la pestaña *Perfiles* y verás las opciones. De las opciones predeterminadas, el perfil *Homebrew* es una elección útil — es texto brillante sobre fondo oscuro, lo que personalmente encuentro más fácil para programar. + +Personalmente uso un fondo oscuro, pero con un texto de colores más sutiles basado en [Solarized](http://ethanschoonover.com/solarized). Puedes descargar y abrir mis preferencias usando el comando **`wget`**. + +```markdown +$ cd ~/temp +$ wget https://github.com/ChristopherA/dotfiles/blob/master/install/osxterminal/christophera-dark.terminal +$ open christophera-dark.terminal +$ rm christophera-dark.terminal +``` + +En las *Preferencias* de *Terminal*, en el panel *General*, establece "Al iniciar abrir: Nueva ventana con perfil" y luego selecciona 'christophera-dark'. + +Puedes configurar el tema de Atom para usar un conjunto similar de colores solarizados oscuros. El tema se llama *Solarized Dark* y viene instalado por defecto con Atom y puede ser activado yendo a la sección de Temas en la vista de Configuración **`comando + -`** y seleccionándolo del menú desplegable de Temas de Sintaxis. + +# **Colores CLI** + +Puedes habilitar colores de sintaxis para cómo varios comandos muestran texto en la línea de comandos. Para ver esto, prueba esto: + +```markdown +$ export CLICOLOR=1 +``` + +Ahora escribe **`ls -la`** y verás que los directorios y archivos se listan con diferentes colores. + +Para compatibilidad con el tema solarizado del terminal, también configuro algunos colores específicos que encuentro que combinan bien: + +```markdown +$ export LSCOLORS=gxfxbEaEBxxEhEhBaDaCaD +$ export LS_COLORS="di=36;40:ln=35;40:so=31;:pi=0;:ex=1;;40:bd=0;:cd=37;:su=37;:sg=0;:tw=0;:ow=0;:" +``` + +Ahora, si quieres que estos colores se muestren cada vez que abras *Terminal*, necesitarás agregarlos a un archivo especial para que siempre se carguen. Este archivo se llama **`~/.bash_profile`**. + +```markdown +$ atom ~/.bash_profile +``` + +Agrega las tres líneas (sin el $), guarda, cierra *Terminal* y lánzalo de nuevo, y verás todos tus ajustes de color como prefieres. + +Hay una aplicación de **`brew`** llamada **`grc`** (por [Generic Colourizer](http://kassiopeia.juls.savba.sk/~garabik/software/grc.html)) que agrega colorización a muchos más comandos que los mencionados anteriormente. + +```markdown +$ brew install grc +==> Downloading http://korpus.juls.savba.sk/~garabik/software/grc/grc_1.9.orig.tar.gz +######################################################################## 100.0% +==> Caveats +New shell sessions will start using GRC after you add this to your profile: + source "`brew --prefix`/etc/grc.bashrc" +==> Summary +🍺 /usr/local/Cellar/grc/1.9: 32 files, 148K, built in 3 seconds +$ +``` + +Al igual que con los colores CLI, necesitarás agregar una línea a tu **`~/.bash_profile`**. Recomiendo una sintaxis ligeramente diferente a la que sugiere **`brew`**: + +```markdown +if [ -f $(brew --prefix)/etc/grc.bashrc ]; then + . $(brew --prefix)/etc/grc.bashrc +fi +``` + +## **Completado de Bash** + +Hay una serie de aplicaciones que no permiten la completación de texto parcial con tabulación de la manera que otras lo hacen. La aplicación **`brew`** llamada **`bash-completion`** (de [http://bash-completion.alioth.debian.org](http://bash-completion.alioth.debian.org/)) hará que muchos más comandos soporten la completación con tabulación. + +```markdown +$ brew install bash-completion +==> Downloading http://bash-completion.alioth.debian.org/files/bash-completion-1.3.tar.bz2 +######################################################################## 100.0% +==> Patching +patching file bash_completion +==> ./configure --prefix=/usr/local/Cellar/bash-completion/1.3 +==> make install +==> Caveats +Add the following lines to your ~/.bash_profile: + if [ -f $(brew --prefix)/etc/bash_completion ]; then + . $(brew --prefix)/etc/bash_completion + fi + +Homebrew's own bash completion script has been installed to + /usr/local/etc/bash_completion.d + +Bash completion has been installed to: + /usr/local/etc/bash_completion.d +==> Summary +🍺 /usr/local/Cellar/bash-completion/1.3: 188 files, 1.1M, built in 20 seconds +$ +``` + +Para instalar bash-completion una vez, escribe **`. $(brew --prefix)/etc/bash_completion`**. Puedes ver todas las aplicaciones que esta receta de **`brew`** añade escribiendo 'complete -p' + +Una vez más, si quieres esto permanentemente, hay algunas líneas más para agregar a tu ~/.bash_profile + +```markdown +if [ -f $(brew --prefix)/etc/bash_completion ]; then + . $(brew --prefix)/etc/bash_completion +fi +``` + +## **Mejor Prompt** + +Puedes personalizar el prompt del shell (la parte antes del $) de varias maneras, pero encuentro que la receta de **`brew`** llamada **`bash-git-prompt`** es bastante poderosa, especialmente una vez que comienzas a usar **`git`**. + +```markdown +$ brew install bash-git-prompt +==> Downloading https://github.com/magicmonty/bash-git-prompt/archive/2.3.5.tar.gz +######################################################################## 100.0% +==> Caveats +You should add the following to your .bashrc (or equivalent): + if [ -f "$(brew --prefix bash-git-prompt)/share/gitprompt.sh" ]; then + GIT_PROMPT_THEME=Default + source "$(brew --prefix bash-git-prompt)/share/gitprompt.sh" + fi +==> Summary +🍺 /usr/local/Cellar/bash-git-prompt/2.3.5: 21 files, 120K, built in 2 seconds +$ +``` + +Para ejecutarlo una vez, escribe: + +```markdown +GIT_PROMPT_THEME=Default +source "$(brew --prefix bash-git-prompt)/share/gitprompt.sh" +``` + +Si te gusta, agrega esto a tu ~/.bash_profile: + +```markdown +if [ -f "$(brew --prefix bash-git-prompt)/share/gitprompt.sh" ]; then + GIT_PROMPT_THEME=Solarized + source "$(brew --prefix bash-git-prompt)/share/gitprompt.sh" +fi +``` + +## **Más herramientas de Git y Github** + +Usarás **`git`** y el servidor *GitHub* regularmente, por lo que estas herramientas añaden funcionalidades adicionales. + +La primera se llama **`hub`**, y proporciona toda la funcionalidad de **`git`**, pero añade algunas características específicas de *GitHub*. + +```markdown +$ brew install hub + +``` + +Dado que **`hub`** es compatible con **`git`**, lo **`alias`** en mi **`~/bash_profile`** + +```markdown +alias git=hub +``` + +La receta de **`brew`** [git-extras](https://github.com/visionmedia/git-extras) añade una serie de comandos **`git`** adicionales útiles, y son compatibles con **`hub`**: + +```markdown +$ brew install git-extras +==> Downloading https://homebrew.bintray.com/bottles/git-extras-2.2.0.yosemite.bottle.tar.gz +######################################################################## 100.0% +==> Pouring git-extras-2.2.0.yosemite.bottle.tar.gz +==> Caveats +Bash completion has been installed to: + /usr/local/etc/bash_completion.d +==> Summary +🍺 /usr/local/Cellar/git-extras/2.2.0: 91 files, 388K +$ +``` + +Finalmente, GitHub ofrece una aplicación GUI de Mac útil llamada [GitHub](https://mac.github.com/) para navegar por los repositorios git. + +```markdown +$ brew cask install github-desktop +``` + +## **Script de preparación de OSX** + +Todas las características de instalación y personalización sugeridas por este tutorial también están automatizadas como parte de un script prepare-osx.sh en [https://github.com/ChristopherA/prepare-osx-for-webdev](https://github.com/ChristopherA/prepare-osx-for-webdev), sin embargo, recomiendo que realices el tutorial primero para entender qué hace este script. \ No newline at end of file diff --git a/es/README.md b/es/README.md new file mode 100644 index 0000000..d339ef0 --- /dev/null +++ b/es/README.md @@ -0,0 +1,15 @@ +# READE.md + +# **Introducción a la línea de comandos de Mac** + +Este repositorio de git contiene un tutorial y archivos asociados para introducir a las personas a la línea de comandos de Mac, con un enfoque en crear una base de habilidades que facilitará a un programador novato aprender habilidades de programación de servidores web y clientes, en particular JavaScript y Node.js. + +- [Parte 1 - Fundamentos de la Línea de comandos](Parte1-Fundamentos_de_la_línea_de_comandos.md) +- [Parte 2 - Preparación e instalación](Parte2-Preparacion_e_instalacion.md) +- [Parte 3 - Personaliza tu entorno](Parte3-Personaliza_tu_entorno.md) + +Este tutorial fue creado por [Christopher Allen](mailto:ChristopherA@LifeWithAlacrity.com) y está licenciado bajo una Licencia Internacional Creative Commons Atribución-CompartirIgual 4.0, basada en el trabajo original en [https://github.com/ChristopherA/intro-mac-commandline](https://github.com/ChristopherA/intro-mac-commandline). + +Todas las características de instalación y personalización sugeridas por este tutorial también están automatizadas como parte de un script prepare-osx.sh en [https://github.com/ChristopherA/prepare-osx-for-webdev](https://github.com/ChristopherA/prepare-osx-for-webdev), sin embargo, recomiendo que realices el tutorial primero para entender qué hace este script. + +[842581](https://blockcounter.vercel.app/) (8/5/2024, 13:42:40) \ No newline at end of file