adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-11-27 04:44:08 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #1603 from damasosanoja/tmux-spanish

Browse Source 
tmux spanish translation
This commit is contained in:
Adam Bard 2015-10-18 11:56:21 +08:00
commit 01dce9f0a2
2 changed files with 467 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
es-es/amd-es.html.markdown Normal file
View File

@ -0,0 +1,214 @@
---
category: tool
tool: amd
contributors:
- ["Frederik Ring", "https://github.com/m90"]
translators:
- ["Damaso Sanoja", "https://github.com/damasosanoja"]
filename: learnamd-es.js
lang: es-es
---
## Iniciando con AMD
El API del **Módulo de Definición Asíncrono** especifica un mecanismo para definir módulos JavaScript de manera tal que tanto el módulo como sus dependencias puedan ser cargadas de manera asíncrona. Esto es particularmente adecuado para el entorno del navegador donde la carga sincronizada de los módulos genera problemas de rendimiento, usabilidad, depuración y acceso de multi-dominios.
### Conceptos básicos
```javascript
// El API básico de AMD consiste en tan solo dos métodos: `define` y `require`
// y se basa en la definición y consumo de los módulos:
// `define(id?, dependencias?, fábrica)` define un módulo
// `require(dependencias, callback)` importa un conjunto de dependencias y
// las consume al invocar el callback
// Comencemos usando define para definir un nuevo módulo
// que no posee dependencias. Lo haremos enviando un nombre
// y una función fábrica para definirla:
define('awesomeAMD', function(){
var isAMDAwesome = function(){
return true;
};
// El valor que regresa la función fábrica del módulo será
// lo que los otros módulos o llamados require recibirán cuando
// soliciten nuestro módulo `awesomeAMD`.
// El valor exportado puede ser cualquier cosa, funciones (constructores),
// objetos, primitivos, incluso indefinidos (aunque eso no ayuda mucho).
return isAMDAwesome;
});
// Ahora definamos otro módulo que dependa de nuestro módulo `awesomeAMD`.
// Observe que ahora hay un argumento adicional que define
// las dependencias de nuestro módulo:
define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
// las dependencias serán enviadas a los argumentos de la fábrica
// en el orden que sean especificadas
var tellEveryone = function(){
if (awesomeAMD()){
alert('This is sOoOo rad!');
} else {
alert('Pretty dull, isn\'t it?');
}
};
return tellEveryone;
});
// Como ya sabemos utilizar define usemos ahora `require` para poner en marcha
// nuestro programa. La firma de `require` es `(arrayOfDependencies, callback)`.
require(['loudmouth'], function(loudmouth){
loudmouth();
});
// Para hacer que este tutorial corra código, vamos a implementar una
// versión muy básica (no-asíncrona) de AMD justo aquí:
function define(name, deps, factory){
// observa como son manejados los módulos sin dependencias
define[name] = require(factory ? deps : [], factory || deps);
}
function require(deps, callback){
var args = [];
// primero recuperemos todas las dependencias que necesita
// el llamado require
for (var i = 0; i < deps.length; i++){
args[i] = define[deps[i]];
}
// satisfacer todas las dependencias del callback
return callback.apply(null, args);
}
// puedes ver este código en acción aquí: http://jsfiddle.net/qap949pd/
```
### Uso en el mundo real con require.js
En contraste con el ejemplo introductorio, `require.js` (la librería AMD más popular) implementa la **A** de **AMD**, permitiéndote cargar los módulos y sus dependencias asincrónicamente via XHR:
```javascript
/* file: app/main.js */
require(['modules/someClass'], function(SomeClass){
// el callback es diferido hasta que la dependencia sea cargada
var thing = new SomeClass();
});
console.log('So here we are, waiting!'); // esto correrá primero
```
Por convención, usualmente guardas un módulo en un fichero. `require.js` puede resolver los nombres de los módulos basados en rutas de archivo, de forma que no tienes que nombrar tus módulos, simplemente referenciarlos usando su ubicación. En el ejemplo `someClass` asumimos que se ubica en la carpeta `modules`, relativa a tu `baseUrl` configurada:
* app/
* main.js
* modules/
* someClass.js
* someHelpers.js
* ...
* daos/
* things.js
* ...
Esto significa que podemos definir `someClass` sin especificar su id de módulo:
```javascript
/* file: app/modules/someClass.js */
define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
// definición de módulo, por supuesto, ocurrirá también asincrónicamente
function SomeClass(){
this.method = function(){/**/};
// ...
}
return SomeClass;
});
```
Para alterar el comportamiento del mapeo de ruta usa `requirejs.config(configObj)` en tu `main.js`:
```javascript
/* file: main.js */
requirejs.config({
baseUrl : 'app',
paths : {
// también puedes cargar módulos desde otras ubicaciones
jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
coolLibFromBower : '../bower_components/cool-lib/coollib'
}
});
require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
// un fichero `main` necesita llamar a require al menos una vez,
// de otra forma jamás correrá el código
coolLib.doFancyStuffWith(helpers.transform($('#foo')));
});
```
Las aplicaciones basadas en `require.js` usualmente tendrán un solo punto de entrada (`main.js`) que se pasa a la etiqueta del script `require.js` como un atributo de datos. Será cargado y ejecutado automáticamente al cargar la página:
```html
<!DOCTYPE html>
<html>
<head>
<title>Cien etiquetas de script? Nunca más!</title>
</head>
<body>
<script src="require.js" data-main="app/main"></script>
</body>
</html>
```
### Optimizar todo un proyecto usando r.js
Muchas personas prefieren usar AMD para la organización del código durante el desarrollo, pero quieren enviar para producción un solo fichero en vez de ejecutar cientos de XHRs en las cargas de página.
`require.js` incluye un script llamado `r.js` (el que probablemente correrás en node.js, aunque Rhino también es soportado) que puede analizar el gráfico de dependencias de tu proyecto, y armar un solo fichero que contenga todos tus módulos (adecuadamente nombrados), minificado y listo para consumo.
Instálalo usando `npm`:
```shell
$ npm install requirejs -g
```
Ahora puedes alimentarlo con un fichero de configuración:
```shell
$ r.js -o app.build.js
```
Para nuestro ejemplo anterior el archivo de configuración luciría así:
```javascript
/* file : app.build.js */
({
name : 'main', // nombre del punto de entrada
out : 'main-built.js', // nombre del fichero donde se escribirá la salida
baseUrl : 'app',
paths : {
// `empty:` le dice a r.js que esto aún debe ser cargado desde el CDN, usando
// la ubicación especificada en `main.js`
jquery : 'empty:',
coolLibFromBower : '../bower_components/cool-lib/coollib'
}
})
```
Para usar el fichero creado en producción, simplemente intercambia `data-main`:
```html
<script src="require.js" data-main="app/main-built"></script>
```
Un increíblemente detallado [resumen de opciones de generación](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponible en el repositorio de GitHub.
### Tópicos no cubiertos en este tutorial
* [Cargador de plugins / transformaciones](http://requirejs.org/docs/plugins.html)
* [Cargando y exportando estilos CommonJS](http://requirejs.org/docs/commonjs.html)
* [Configuración avanzada](http://requirejs.org/docs/api.html#config)
* [Configuración de Shim (cargando módulos no-AMD)](http://requirejs.org/docs/api.html#config-shim)
* [Cargando y optimizando CSS con require.js](http://requirejs.org/docs/optimization.html#onecss)
* [Usando almond.js para construcciones](https://github.com/jrburke/almond)
### Otras lecturas:
* [Especificaciones oficiales](https://github.com/amdjs/amdjs-api/wiki/AMD)
* [¿Por qué AMD?](http://requirejs.org/docs/whyamd.html)
* [Definición Universal de Módulos](https://github.com/umdjs/umd)
### Implementaciones:
* [require.js](http://requirejs.org)
* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
* [cujo.js](http://cujojs.com/)
* [curl.js](https://github.com/cujojs/curl)
* [lsjs](https://github.com/zazl/lsjs)
* [mmd](https://github.com/alexlawrence/mmd)

253
es-es/tmux-es.html.markdown Normal file
View File

@ -0,0 +1,253 @@
---
category: tool
tool: tmux
contributors:
- ["mdln", "https://github.com/mdln"]
filename: LearnTmux-es.txt
translators:
- ["Damaso Sanoja", "https://github.com/damasosanoja"]
lang: es-es
---
[tmux](http://tmux.sourceforge.net)
es un terminal multiplexor: habilita la creación, acceso y control
de múltiples terminales controlados desde una sola pantalla. tmux
puede ser separado de una pantalla y continuar corriendo en el fondo
y luego ser insertado nuevamente.
```
tmux [command] # Corre un comando
# 'tmux' sin comandos creará una nueva sesión
new # Crea una nueva sesión
-s "Session" # Crea sesión con nombre
-n "Window" # Crea ventana con nombre
-c "/dir" # Comienza en el directorio destino
attach # Adjunta sesión última/disponible
-t "#" # Adjunta sesión destino
-d # Separa la sesión de otras instancias
ls # Lista las sesiones abiertas
-a # Lista todas las sesiones abiertas
lsw # Lista las ventanas
-a # Lista todas las ventanas
-s # Lista todas las ventanas en la sesión
lsp # Lista los páneles
-a # Lista todos los páneles
-s # Lista todos los páneles de la sesión
-t # Lista los páneles de aplicación en el destino
kill-window # Cierra la ventana actual
-t "#" # Cierra la ventana destino
-a # Cierra todas las ventanas
-a -t "#" # Cierra todas las ventanas menos el destino
kill-session # Cierra la sesión actual
-t "#" # Cierra la sesión destino
-a # Cierra todas las sesiones
-a -t "#" # Cierra todas las sesiones menos el destino
```
### Atajos de Teclado
El método para controlar una sesión adjunta tmux es mediante
combinaciones de teclas llamadas teclas 'Prefijo'.
```
----------------------------------------------------------------------
(C-b) = Ctrl + b # combinación 'Prefijo' necesaria para usar atajos
(M-1) = Meta + 1 -o- Alt + 1
----------------------------------------------------------------------
? # Lista todos los atajos de teclado
: # Entra en la línea de comandos tmux
r # Fuerza el redibujado del cliente adjuntado
c # Crea una nueva ventana
! # Separa el panel actual fuera de la ventana.
% # Separa el panel actual en dos, izquierdo y derecho
" # Separa el panel actual en dos, superior e inferior
n # Cambia a la siguiente ventana
p # Cambia a la ventana previa
{ # Intercambia el panel actual con el anterior
} # Intercambia el panel actual con el próximo
s # Selecciona una nueva sesión para el cliente adjuntado
interactivamente
w # Elegir la ventana actual interactivamente
0 al 9 # Seleccionar ventanas 0 al 9
d # Separa el cliente actual
D # Elige un cliente para separar
& # Cierra la ventana actual
x # Cierra el panel actual
Up, Down # Cambia al panel superior, inferior, izquierdo, o derecho
Left, Right
M-1 to M-5 # Organizar páneles:
# 1) uniformes horizontales
# 2) uniformes verticales
# 3) principal horizontal
# 4) principal vertical
# 5) mozaico
C-Up, C-Down # Redimensiona el panel actual en pasos de una celda
C-Left, C-Right
M-Up, M-Down # Redimensiona el panel actual en pasos de cinco celdas
M-Left, M-Right
```
### Configurando ~/.tmux.conf
tmux.conf puede usarse para establecer opciones automáticas al arrancar, parecido a como .vimrc o init.el hacen.
```
# Ejemplo de tmux.conf
# 2014.10
### General
###########################################################################
# Habilita UTF-8
setw -g utf8 on
set-option -g status-utf8 on
# Fuera de pantalla/Historia límite
set -g history-limit 2048
# Comienzo de índice
set -g base-index 1
# Ratón
set-option -g mouse-select-pane on
# Forza recarga de fichero de configuración
unbind r
bind r source-file ~/.tmux.conf
### Atajos de teclado
###########################################################################
# Desvincula C-b como el prefijo por defecto
unbind C-b
# Establece el nuevo prefijo
set-option -g prefix `
# Regresa a la ventana previa cuando el prefijo es accionado dos veces
bind C-a last-window
bind ` last-window
# Permite intercambiar C-a y ` usando F11/F12
bind F11 set-option -g prefix C-a
bind F12 set-option -g prefix `
# Preferencias de atajos
setw -g mode-keys vi
set-option -g status-keys vi
# Moviéndose entre paneles con movimientos de teclas vim
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R
# Ciclo/Intercambio de Ventana
bind e previous-window
bind f next-window
bind E swap-window -t -1
bind F swap-window -t +1
# División rápida de paneles
bind = split-window -h
bind - split-window -v
unbind '"'
unbind %
# Activar sesión mas interna (cuando se anida tmux) para enviar comandos
bind a send-prefix
### Temas
###########################################################################
# Paleta de Colores de la Barra de estado
set-option -g status-justify left
set-option -g status-bg black
set-option -g status-fg white
set-option -g status-left-length 40
set-option -g status-right-length 80
# Paleta de Colores del Borde del Panel
set-option -g pane-active-border-fg green
set-option -g pane-active-border-bg black
set-option -g pane-border-fg white
set-option -g pane-border-bg black
# Paleta de Colores de Mensajes
set-option -g message-fg black
set-option -g message-bg green
# Paleta de Colores de la Ventana
setw -g window-status-bg black
setw -g window-status-current-fg green
setw -g window-status-bell-attr default
setw -g window-status-bell-fg red
setw -g window-status-content-attr default
setw -g window-status-content-fg yellow
setw -g window-status-activity-attr default
setw -g window-status-activity-fg yellow
### UI
###########################################################################
# Notificación
setw -g monitor-activity on
set -g visual-activity on
set-option -g bell-action any
set-option -g visual-bell off
# Establece automáticamente títulos de ventanas
set-option -g set-titles on
set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
# Ajustes de barra de estado
set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
# Muestra indicadores de rendimiento en barra de estado
# Requiere https://github.com/thewtex/tmux-mem-cpu-load/
set -g status-interval 4
set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
```
### Referencias
[Tmux | Inicio](http://tmux.sourceforge.net)
[Tmux Manual](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
[Mostrar CPU/MEM % en barra de estado](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)