mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2025-05-08 15:58:33 +00:00
Daniel Zendejas
commit
2cfc0752b4
87
es-es/brainfuck-es.html.markdown
Normal file
87
es-es/brainfuck-es.html.markdown
Normal file
@ -0,0 +1,87 @@
|
|||||||
|
---
|
||||||
|
language: brainfuck
|
||||||
|
contributors:
|
||||||
|
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
|
||||||
|
- ["Mathias Bynens", "http://mathiasbynens.be/"]
|
||||||
|
translators:
|
||||||
|
- ["Daniel Zendejas", "https://github.com/DanielZendejas"]
|
||||||
|
lang: es-es
|
||||||
|
---
|
||||||
|
|
||||||
|
Brainfuck (con mayúscula sólo al inicio de una oración) es un
|
||||||
|
lenguaje de programación mínimo, computacionalmente universal
|
||||||
|
en tamaño con sólo 8 comandos.
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
|
||||||
|
será ignorado.
|
||||||
|
|
||||||
|
Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
|
||||||
|
en cero y un apuntador en la celda actual.
|
||||||
|
|
||||||
|
Existen ocho comandos:
|
||||||
|
|
||||||
|
+ : Incrementa 1 al valor de la celda actual.
|
||||||
|
- : Decrementa 1 al valor de la celda actual.
|
||||||
|
> : Mueve el apuntador a la siguiente celda. (a la derecha)
|
||||||
|
< : Mueve el apuntador a la celda anterior. (a la izquierda)
|
||||||
|
. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A')
|
||||||
|
, : Lee un caracter como input y lo escribe en la celda actual.
|
||||||
|
[ : Si el valor en la celda actual es cero mueve el apuntador
|
||||||
|
hasta el primer ']' que encuentre. Si no es cero sigue a la
|
||||||
|
siguiente instrucción.
|
||||||
|
] : Si el valor en la celda actual es cero, entonces sigue con
|
||||||
|
la siguiente instrucción. Si no entonces mueve el apuntador
|
||||||
|
hacia atrás hasta encontrar el primer '['.
|
||||||
|
|
||||||
|
[ y ] forman un while. Obviamente, deben estar balanceados.
|
||||||
|
|
||||||
|
Ahora unos ejemplos de programas escritos con brainfuck.
|
||||||
|
|
||||||
|
++++++ [ > ++++++++++ < - ] > +++++ .
|
||||||
|
|
||||||
|
Este programa imprime la letra 'A'. Primero, incrementa la celda #1 a
|
||||||
|
6. La celda #1 será usada para hacer los ciclos. Después entra al ciclo
|
||||||
|
([) y se mueve a la celda #2 (>). Después incrementa la celda #2 10 veces,
|
||||||
|
y se regresa a la celda #1 (<), para después decrementarla en 1 (-).
|
||||||
|
Este ciclo ocurre 6 veces (le toma 6 decrementos a la celda #1 volverse 0),
|
||||||
|
cuando esto pasa se salta a (]) y continúa.
|
||||||
|
|
||||||
|
En este punto estamos en la celda #1, que tiene un valor de 0, mientras
|
||||||
|
que la celda #2 tiene un valor de 60. Nos movemos a la celda #2 (>),
|
||||||
|
la incrementamos 5 veces para tener un valor de 65 y luego imprimimos
|
||||||
|
el valor de la celda #2 (.). 65 es 'A' en ASCII así que la letra 'A'
|
||||||
|
se imprime.
|
||||||
|
|
||||||
|
, [ > + < - ] > .
|
||||||
|
|
||||||
|
Este programa lee un caracter del input y lo copia en la celda #2 (,).
|
||||||
|
Después empieza un ciclo. Nos movemos a la celda #2 (>) e incrementamos su
|
||||||
|
valor (+). Regresamos a la celda #1 y decrementamos su valor en 1 (-).
|
||||||
|
Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un
|
||||||
|
cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
|
||||||
|
terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
|
||||||
|
|
||||||
|
Ten en mente que los espacios son sólo para fines de legibilidad.
|
||||||
|
Es lo mismo escribir el ejemplo de arriba que esto:
|
||||||
|
,[>+<-]>.
|
||||||
|
|
||||||
|
Intenta descrifrar lo que hace este programa:
|
||||||
|
|
||||||
|
,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
|
||||||
|
|
||||||
|
Este programa toma dos números como input y los multiplica.
|
||||||
|
|
||||||
|
Primero recibe dos números del usuario. Luego empieza el ciclo externo,
|
||||||
|
condicionado en la celda #1. Luego se mueve a la celda #2, comenzando
|
||||||
|
el ciclo interno condicionado en la celda #2 incrementando la celda #3.
|
||||||
|
Sin embargo viene un problema: El ciclo interior no funcionará nuevamente
|
||||||
|
hasta la próxima vez. Para resolver este problema también incrementamos la
|
||||||
|
celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
|
||||||
|
el resultado.
|
||||||
|
```
|
||||||
|
Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir
|
||||||
|
tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
|
||||||
|
intérprete es relativamente sencillo de hacer, pero si eres masoquista,
|
||||||
|
intenta construir tu proprio intérprete de brainfuck... en brainfuck.
|
||||||
131
es-es/xml-es.html.markdown
Normal file
131
es-es/xml-es.html.markdown
Normal file
@ -0,0 +1,131 @@
|
|||||||
|
---
|
||||||
|
language: xml
|
||||||
|
filename: learnxml.xml
|
||||||
|
contributors:
|
||||||
|
- ["João Farias", "https://github.com/JoaoGFarias"]
|
||||||
|
translators:
|
||||||
|
- ["Daniel Zendejas", "https://github.com/DanielZendejas"]
|
||||||
|
lang: es-es
|
||||||
|
---
|
||||||
|
XML es un lenguaje diseñado para guardar y transportar datos
|
||||||
|
|
||||||
|
A diferencia de HTML, XML no especifica cómo desplegar la información,
|
||||||
|
sólo la guarda.
|
||||||
|
|
||||||
|
* Sintaxis XML
|
||||||
|
|
||||||
|
```xml
|
||||||
|
<!-- Los comentarios en XML son de esta forma -->
|
||||||
|
|
||||||
|
<?xml version="1.0" encoding="UTF-8"?>
|
||||||
|
<tiendaDeLibros>
|
||||||
|
<libro categoria="COCINA">
|
||||||
|
<titulo lenguaje="en">Everyday Italian</titulo>
|
||||||
|
<autor>Giada De Laurentiis</autor>
|
||||||
|
<anio>2005</anio>
|
||||||
|
<precio>30.00</precio>
|
||||||
|
</libro>
|
||||||
|
<libro categoria="INFANTES">
|
||||||
|
<titulo lenguaje="en">Harry Potter</titulo>
|
||||||
|
<autor>J K. Rowling</autor>
|
||||||
|
<anio>2005</anio>
|
||||||
|
<precio>29.99</precio>
|
||||||
|
</libro>
|
||||||
|
<libro categoria="WEB">
|
||||||
|
<titulo lenguaje="en">Learning XML</titulo>
|
||||||
|
<autor>Erik T. Ray</autor>
|
||||||
|
<anio>2003</anio>
|
||||||
|
<precio>39.95</precio>
|
||||||
|
</libro>
|
||||||
|
</tiendaDeLibros>
|
||||||
|
|
||||||
|
<!-- Este es un archivo típico de XML.
|
||||||
|
Empieza con una declaración de metadatos (opcional).
|
||||||
|
|
||||||
|
XML usa una estructura de árbol. El nodo raíz es 'tiendaDeLibros', el cual
|
||||||
|
tiene tres nodos hijos, todos llamados 'libros'.
|
||||||
|
Esos nodos tienen más nodos hijos, y así continúa...
|
||||||
|
|
||||||
|
Los nodos son creados usando tags que abren y cierran, y los hijos
|
||||||
|
son sólo nodos entre estas tags.-->
|
||||||
|
|
||||||
|
|
||||||
|
<!-- XML guarda dos tipos de datos:
|
||||||
|
1 - Atributos -> Son los metadatos de un nodo.
|
||||||
|
Usualmente el parseador XML usa esta información para guardar los datos
|
||||||
|
apropiadamente. Aparecen con el formato (nombre="valor") dentro de la
|
||||||
|
tag que abre.
|
||||||
|
2 - Elementos -> Ese es el dato puro.
|
||||||
|
Eso es lo que el parseador recuperará del archivo XML.
|
||||||
|
Los elementos aparecen entre las tags que abren y cierran.-->
|
||||||
|
|
||||||
|
|
||||||
|
<!-- Debajo, un elemento con dos atributos. -->
|
||||||
|
<archivo tipo="gif" id="4293">computer.gif</archivo>
|
||||||
|
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
* Documentos con buen formato x Validación
|
||||||
|
|
||||||
|
Un documento XML está bien formado cuando es sintácticamente correcto.
|
||||||
|
Aún esto, es posible inyectar más restricciones en el documento,
|
||||||
|
usando definiciones de documento, así como DTD o XML Schemas.
|
||||||
|
|
||||||
|
Un documento XML que sigue a una definición de documento (un esquema) es
|
||||||
|
válida.
|
||||||
|
|
||||||
|
Con esta herramienta puedes validar datos XML fuera de la aplicación
|
||||||
|
|
||||||
|
```xml
|
||||||
|
|
||||||
|
<!-- Debajo puedes encontrar una versión simplificada del documento
|
||||||
|
tiendaDeLibros en adición a la definición DTD.-->
|
||||||
|
|
||||||
|
<?xml version="1.0" encoding="UTF-8"?>
|
||||||
|
<!DOCTYPE note SYSTEM "tiendaDeLibros.dtd">
|
||||||
|
<tiendaDeLibros>
|
||||||
|
<libro categoriq="COCINA">
|
||||||
|
<titulo>Everyday Italian</titulo>
|
||||||
|
<precio>30.00</precio>
|
||||||
|
</libro>
|
||||||
|
</tiendaDeLibros>
|
||||||
|
|
||||||
|
<!-- El DTD de este documento podría verse algo así:-->
|
||||||
|
|
||||||
|
<!DOCTYPE note
|
||||||
|
[
|
||||||
|
<!ELEMENT tiendaDeLibros (libro+)>
|
||||||
|
<!ELEMENT libro (titulo,precio)>
|
||||||
|
<!ATTLIST libro categoria CDATA "Literatura">
|
||||||
|
<!ELEMENT titulo (#PCDATA)>
|
||||||
|
<!ELEMENT precio (#PCDATA)>
|
||||||
|
]>
|
||||||
|
|
||||||
|
<!--El DTD empieza con una declaración.
|
||||||
|
Después el nodo raíz es declarado, requiriendo 1 o más nodos 'libro'
|
||||||
|
Cada 'libro' debe contener exactamente un 'titulo' y un 'precio' y
|
||||||
|
un atributo llamado 'categoria', con "Literatura" como su valor
|
||||||
|
default.
|
||||||
|
Los nodos 'titulo' y 'precio' contienen datos de caracteres
|
||||||
|
parseados.
|
||||||
|
|
||||||
|
El DTD puede ser declarado dentro del XML mismo.-->
|
||||||
|
|
||||||
|
<?xml version="1.0" encoding="UTF-8"?>
|
||||||
|
|
||||||
|
<!DOCTYPE note
|
||||||
|
[
|
||||||
|
<!ELEMENT tiendaDeLibros (libro+)>
|
||||||
|
<!ELEMENT libro (titulo,precio)>
|
||||||
|
<!ATTLIST libro categoria CDATA "Literatura">
|
||||||
|
<!ELEMENT titulo (#PCDATA)>
|
||||||
|
<!ELEMENT precio (#PCDATA)>
|
||||||
|
]>
|
||||||
|
<tiendaDeLibros>
|
||||||
|
<libro categoriq="COCINA">
|
||||||
|
<titulo>Everyday Italian</titulo>
|
||||||
|
<precio>30.00</precio>
|
||||||
|
</libro>
|
||||||
|
</tiendaDeLibros>
|
||||||
|
```
|
||||||
150
es-es/yaml-es.html.markdown
Normal file
150
es-es/yaml-es.html.markdown
Normal file
@ -0,0 +1,150 @@
|
|||||||
|
---
|
||||||
|
language: yaml
|
||||||
|
filename: learnyaml-es.yaml
|
||||||
|
contributors:
|
||||||
|
- ["Adam Brenecki", "https://github.com/adambrenecki"]
|
||||||
|
translators:
|
||||||
|
- ["Daniel Zendejas","https://github.com/DanielZendejas"]
|
||||||
|
---
|
||||||
|
Tutorial de YAML en español.
|
||||||
|
|
||||||
|
YAML es un lenguaje de serialización de datos diseñado para ser
|
||||||
|
leído y escrito por humanos.
|
||||||
|
|
||||||
|
Basa su funcionalidad en JSON, con la adición de líneas nuevas
|
||||||
|
e indentación inspirada en Python. A diferencia de Python, YAML
|
||||||
|
no permite tabs literales.
|
||||||
|
|
||||||
|
```yaml
|
||||||
|
# Los comentarios en YAML se ven así.
|
||||||
|
|
||||||
|
###################
|
||||||
|
# TIPOS ESCALARES #
|
||||||
|
###################
|
||||||
|
|
||||||
|
# Nuestro objeto raíz (el cual es el mismo a lo largo de todo el
|
||||||
|
# documento) será un mapa, equivalente a un diccionario, hash,
|
||||||
|
# u objeto en otros lenguajes.
|
||||||
|
|
||||||
|
llave: valor
|
||||||
|
otra_llave: Otro valor
|
||||||
|
un_valor_numerico: 100
|
||||||
|
notacion_cientifica: 1e+12
|
||||||
|
booleano: true
|
||||||
|
valor_nulo: null
|
||||||
|
llave con espacios: valor
|
||||||
|
# Nótese que los strings no deben estar entre comillas, aunqué también es válido.
|
||||||
|
llave: "Un string, entre comillas."
|
||||||
|
"Las llaves tambien pueden estar entre comillas.": "valor entre comillas"
|
||||||
|
|
||||||
|
# Los strings de líneas múltiples pueden ser escritos
|
||||||
|
# como un 'bloque literal' (usando pipes |)
|
||||||
|
# o como un 'bloque doblado' (usando >)
|
||||||
|
|
||||||
|
bloque_literal: |
|
||||||
|
Este bloque completo de texto será preservado como el valor de la llave
|
||||||
|
'bloque_literal', incluyendo los saltos de línea.
|
||||||
|
|
||||||
|
Se continúa guardando la literal hasta que se cese la indentación.
|
||||||
|
Cualquier línea que tenga más indentación, mantendrá los espacios dados
|
||||||
|
(por ejemplo, estas líneas se guardarán con cuatro espacios)
|
||||||
|
|
||||||
|
nloque_doblado: >
|
||||||
|
De la misma forma que el valor de 'bloque_literal', todas estas
|
||||||
|
líneas se guardarán como una sola literal, pero en esta ocasión todos los
|
||||||
|
saltos de línea serán reemplazados por espacio.
|
||||||
|
|
||||||
|
Las líneas en blanco, como la anterior, son convertidos a un salto de línea.
|
||||||
|
|
||||||
|
Las líneas con mayor indentación guardan sus saltos de línea.
|
||||||
|
Esta literal ocuparán dos líneas.
|
||||||
|
|
||||||
|
########################
|
||||||
|
# TIPOS DE COLECCIONES #
|
||||||
|
########################
|
||||||
|
|
||||||
|
# La indentación se usa para anidar.
|
||||||
|
un_mapa_indentado:
|
||||||
|
llave: valor
|
||||||
|
otra_llave: otro valor
|
||||||
|
otro_mapa_indentado:
|
||||||
|
llave_interna: valor_interno
|
||||||
|
|
||||||
|
# Las llaves de los mapas no deben ser strings necesariamente
|
||||||
|
0.25: una llave numérica
|
||||||
|
|
||||||
|
# Las llaves también pueden ser objetos de multi línea, usando ? para indicar
|
||||||
|
# el inicio de una llave
|
||||||
|
? |
|
||||||
|
Esto es una llave
|
||||||
|
que tiene múltiples líneas
|
||||||
|
: y este es su valor
|
||||||
|
|
||||||
|
# YAML tambien permite colecciones como llaves, pero muchos lenguajes de
|
||||||
|
# programación se quejarán.
|
||||||
|
|
||||||
|
# Las secuencias (equivalentes a listas o arreglos) se ven así:
|
||||||
|
una_secuencia:
|
||||||
|
- Item 1
|
||||||
|
- Item 2
|
||||||
|
- 0.5 # las secuencias pueden tener distintos tipos en su contenido.
|
||||||
|
- Item 4
|
||||||
|
- llave: valor
|
||||||
|
otra_llave: otro_valor
|
||||||
|
-
|
||||||
|
- Esta es una secuencia
|
||||||
|
- ...dentro de otra secuencia
|
||||||
|
|
||||||
|
# Dado que todo JSON está incluído dentro de YAML, también puedes escribir
|
||||||
|
# mapas con la sintaxis de JSON y secuencias:
|
||||||
|
mapa_de_json: {"llave": "valor"}
|
||||||
|
secuencia_de_json: [3, 2, 1, "despegue"]
|
||||||
|
|
||||||
|
##################################
|
||||||
|
# CARACTERÍSTICAS EXTRAS DE YAML #
|
||||||
|
##################################
|
||||||
|
|
||||||
|
# YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten
|
||||||
|
# duplicar fácilmente contenido a lo largo de tu documento. En el ejemplo
|
||||||
|
# a continuación, ambas llaves tendrán el mismo valor:
|
||||||
|
contenido_anclado: &nombre_del_ancla Este string será el valor de las llaves
|
||||||
|
otra_ancla: *nombre_del_ancla
|
||||||
|
|
||||||
|
# YAML también tiene tags, que puedes usar para declarar tipos explícitamente.
|
||||||
|
string_explícito: !!str 0.5
|
||||||
|
# Algunos parseadores implementar tags específicas del lenguaje, como el
|
||||||
|
# que se muestra a continuación, encargado de manejar números complejos en
|
||||||
|
# Python:
|
||||||
|
numero_complejo_python: !!python/complex 1+2j
|
||||||
|
|
||||||
|
########################
|
||||||
|
# TIPOS EXTRAS EN YAML #
|
||||||
|
########################
|
||||||
|
|
||||||
|
# Stirngs y números no son los únicos escalares que YAML puede entener.
|
||||||
|
# YAML también puede parsear fechas en formato ISO .
|
||||||
|
fechaHora: 2001-12-15T02:59:43.1Z
|
||||||
|
fechaHora_con_espacios: 2001-12-14 21:59:43.10 -5
|
||||||
|
fecha: 2002-12-14
|
||||||
|
|
||||||
|
# La tag !!binary indica que un string es, en realidad, un blob
|
||||||
|
# representado en base-64.
|
||||||
|
archivo_gif: !!binary |
|
||||||
|
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
|
||||||
|
OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
|
||||||
|
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
|
||||||
|
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
|
||||||
|
|
||||||
|
# YAML también tiene un tipo set, que se ve de la siguiente forma:
|
||||||
|
set:
|
||||||
|
? item1
|
||||||
|
? item2
|
||||||
|
? item3
|
||||||
|
|
||||||
|
# Al igual que Python, los sets sólo son mapas con valores nulos.
|
||||||
|
# El ejemplo de arriba es equivalente a:
|
||||||
|
set2:
|
||||||
|
item1: null
|
||||||
|
item2: null
|
||||||
|
item3: null
|
||||||
|
```
|
||||||
Loading…
Reference in New Issue
Block a user