Cambio arreglos por vectores

ldonofrio · ldonofrio · commit 3455d9325ee7 · 2012-12-20T11:38:46.000-03:00
diff --git a/figuras/70415e9fffab1c47953f5264ecf722fe.png b/figuras/70415e9fffab1c47953f5264ecf722fe.png
diff --git a/libro/epub/Fundamentos_de_jQuery.epub b/libro/epub/Fundamentos_de_jQuery.epub
diff --git a/libro/html/index.html b/libro/html/index.html
diff --git a/libro/markdown/cap02-conceptos-basicos-javascript.markdown b/libro/markdown/cap02-conceptos-basicos-javascript.markdown
@@ -243,7 +243,7 @@ Para controlar el flujo adecuadamente, es importante entender qué tipos de valo
 ```javascript
 '0';
 'any string'; // cualquier cadena
-[];  // un arreglo vacío
+[];  // un vector vacío
 {};  // un objeto vacío
 1;   // cualquier número distinto a cero
 ```
@@ -542,53 +542,53 @@ JavaScript posee un número de "palabras reservadas", o palabras que son especia
 
 
 
-## Arreglos
+## Vectores
 
-Los arreglos (en inglés *arrays*) son listas de valores con índice-cero (en inglés *zero-index*), es decir, que el primer elemento del arreglo está en el índice 0. Éstos son una forma práctica de almacenar un conjunto de datos relacionados (como cadenas de caracteres), aunque en realidad, un arreglo puede incluir múltiples tipos de datos, incluso otros arreglos.
+Los vectores (en español también llamados *matrices* o *arreglos* y en inglés *arrays*) son listas de valores con índice-cero (en inglés *zero-index*), es decir, que el primer elemento del vector está en el índice 0. Éstos son una forma práctica de almacenar un conjunto de datos relacionados (como cadenas de caracteres), aunque en realidad, un vector puede incluir múltiples tipos de datos, incluso otros vectores.
 
 
-**Un arreglo simple**
+**Un vector simple**
 
 ```javascript
 var myArray = [ 'hello', 'world' ];
 ```
 
 
-**Acceder a los ítems del arreglo a través de su índice**
+**Acceder a los ítems del vector a través de su índice**
 
 ```javascript
 var myArray = [ 'hello', 'world', 'foo', 'bar' ];
 console.log(myArray[3]);   // muestra en la consola 'bar'
 ```
 
 
-**Obtener la cantidad de ítems del arreglo**
+**Obtener la cantidad de ítems del vector**
 
 ```javascript
 var myArray = [ 'hello', 'world' ];
 console.log(myArray.length);   // muestra en la consola 2
 ```
 
 
-**Cambiar el valor de un ítem de un arreglo**
+**Cambiar el valor de un ítem de un vector**
 
 ```javascript
 var myArray = [ 'hello', 'world' ];
 myArray[1] = 'changed';
 ```
 
-*Como se muestra en el ejemplo "Cambiar el valor de un ítem de un arreglo" es posible cambiar el valor de un ítem de un arreglo, sin embargo, por lo general, no es aconsejable.*
+*Como se muestra en el ejemplo "Cambiar el valor de un ítem de un vector" es posible cambiar el valor de un ítem de un vector, sin embargo, por lo general, no es aconsejable.*
 
 
-**Añadir elementos a un arreglo**
+**Añadir elementos a un vector**
 
 ```javascript
 var myArray = [ 'hello', 'world' ];
 myArray.push('new');
 ```
 
 
-**Trabajar con arreglos**
+**Trabajar con vectores**
 
 ```javascript
 var myArray = [ 'h', 'e', 'l', 'l', 'o' ];
@@ -600,11 +600,11 @@ var mySplit = myString.split('');  // [ 'h', 'e', 'l', 'l', 'o' ]
 
 ## Objetos
 
-Los objetos son elementos que pueden contener cero o más conjuntos de pares de nombres claves y valores asociados a dicho objeto. Los nombres claves pueden ser cualquier palabra o número válido. El valor puede ser cualquier tipo de valor: un número, una cadena, un arreglo, una función, incluso otro objeto.
+Los objetos son elementos que pueden contener cero o más conjuntos de pares de nombres claves y valores asociados a dicho objeto. Los nombres claves pueden ser cualquier palabra o número válido. El valor puede ser cualquier tipo de valor: un número, una cadena, un vector, una función, incluso otro objeto.
 
 [Definición: Cuando uno de los valores de un objeto es una función, ésta es nombrada como un *método* del objeto.] De lo contrario, se los llama *propiedades*.
 
-Curiosamente, en JavaScript, casi todo es un objeto — arreglos, funciones, números, incluso cadenas — y todos poseen propiedades y métodos.
+Curiosamente, en JavaScript, casi todo es un objeto — vectores, funciones, números, incluso cadenas — y todos poseen propiedades y métodos.
 
 
 **Creación de un "objeto literal"**
@@ -764,7 +764,7 @@ myFn(myOtherFn);   // muestra en la consola 'hello world'
 
 ## Determinación del Tipo de Variable
 
-JavaScript ofrece una manera de poder comprobar el "tipo" (en inglés *type*) de una variable. Sin embargo, el resultado puede ser confuso — por ejemplo, el tipo de un arreglo es "object".
+JavaScript ofrece una manera de poder comprobar el "tipo" (en inglés *type*) de una variable. Sin embargo, el resultado puede ser confuso — por ejemplo, el tipo de un vector es "object".
 
 Por eso, es una práctica común utilizar el operador `typeof` cuando se trata de determinar el tipo de un valor específico.
 
@@ -796,14 +796,14 @@ typeof null;         // devuelve 'object' -- tenga cuidado
 
 
 if (myArray.push && myArray.slice && myArray.join) {
-    // probablemente sea un arreglo
+    // probablemente sea un vector
     // (este estilo es llamado, en inglés, "duck typing")
 }
 
 if (Object.prototype.toString.call(myArray) === '[object Array]') {
-    // definitivamente es un arreglo;
+    // definitivamente es un vector;
     // esta es considerada la forma más robusta
-    // de determinar si un valor es un arreglo.
+    // de determinar si un valor es un vector.
 }
 ```
 
diff --git a/libro/markdown/cap03-conceptos-basicos-jquery.markdown b/libro/markdown/cap03-conceptos-basicos-jquery.markdown
@@ -676,7 +676,7 @@ $('ul').append('<li>item de la lista</li>');
 
 > **Nota**
 >
-> La sintaxis para añadir nuevos elementos a la página es muy fácil de utilizar, pero es tentador olvidar que hay un costo enorme de rendimiento al agregar elementos al DOM de forma repetida. Si esta añadiendo muchos elementos al mismo contenedor, en lugar de añadir cada elemento uno por vez, lo mejor es concatenar todo el HTML en una única cadena de caracteres para luego anexarla al contenedor. Una posible solución es utilizar un arreglo que posea todos los elementos, luego reunirlos utilizando `join` y finalmente anexarla.
+> La sintaxis para añadir nuevos elementos a la página es muy fácil de utilizar, pero es tentador olvidar que hay un costo enorme de rendimiento al agregar elementos al DOM de forma repetida. Si esta añadiendo muchos elementos al mismo contenedor, en lugar de añadir cada elemento uno por vez, lo mejor es concatenar todo el HTML en una única cadena de caracteres para luego anexarla al contenedor. Una posible solución es utilizar un vector que posea todos los elementos, luego reunirlos utilizando `join` y finalmente anexarla.
 
 
 ```javascript
diff --git a/libro/markdown/cap04-nucleo-jquery.markdown b/libro/markdown/cap04-nucleo-jquery.markdown
@@ -37,7 +37,7 @@ $.trim('    varios espacios en blanco   ');
 ```
 
  $.each
-  ~ Interactúa en arreglos y objetos.
+  ~ Interactúa en vectores y objetos.
 
 ```javascript
 $.each([ 'foo', 'bar', 'baz' ], function(idx, val) {
@@ -56,7 +56,7 @@ $.each({ foo : 'bar', baz : 'bim' }, function(k, v) {
 
 
  $.inArray
-  ~ Devuelve el índice de un valor en un arreglo, o -1 si el valor no se encuentra en el arreglo.
+  ~ Devuelve el índice de un valor en un vector, o -1 si el valor no se encuentra en el vector.
 
 ```javascript
 var myArray = [ 1, 2, 3, 5 ];
diff --git a/libro/markdown/cap07-ajax.markdown b/libro/markdown/cap07-ajax.markdown
@@ -45,7 +45,7 @@ Generalmente, jQuery necesita algunas instrucciones sobre el tipo de informació
   ~ Para añadir un nuevo *script* con código JavaScript a la página.
 
  json
-  ~ Para transportar información en formato JSON, el cual puede incluir cadenas de caracteres, arreglos y objetos.
+  ~ Para transportar información en formato JSON, el cual puede incluir cadenas de caracteres, vectores y objetos.
 
 
 > **Nota**
@@ -214,7 +214,7 @@ Como se comentó anteriormente, para una lista completa de las opciones disponib
 
 > **Nota**
 >
-> A partir de la versión 1.5 de jQuery, las opciones `success`, `error` y `complete` pueden recibir un arreglo con varias funciones de devolución, las cuales serán ejecutadas en turnos.
+> A partir de la versión 1.5 de jQuery, las opciones `success`, `error` y `complete` pueden recibir un vector con varias funciones de devolución, las cuales serán ejecutadas en turnos.
 > 
 
 
@@ -320,7 +320,7 @@ $('#myForm').serialize();
 ```
 
 
-**Crear un arreglo de objetos conteniendo información de un formulario**
+**Crear un vector de objetos conteniendo información de un formulario**
 
 ```javascript
 $('#myForm').serializeArray();
diff --git a/libro/markdown/cap09-mejoras-rendimiento.markdown b/libro/markdown/cap09-mejoras-rendimiento.markdown
@@ -6,7 +6,7 @@ Este capítulo cubre numerosas mejores prácticas de JavaScript y jQuery,sin un
 
 ## Guardar la Longitud en Bucles
 
-En un bucle, no es necesario acceder a la longitud de un arreglo cada vez que se evalúa la condición; dicho valor se puede guardar previamente en una variable.
+En un bucle, no es necesario acceder a la longitud de un vector cada vez que se evalúa la condición; dicho valor se puede guardar previamente en una variable.
 
 ```javascript
 var myLength = myArray.length;
diff --git a/libro/markdown/cap10-organizacion-codigo.markdown b/libro/markdown/cap10-organizacion-codigo.markdown
@@ -359,7 +359,7 @@ require.def("my/simpleshirt",
 
 El ejemplo debe ser guardado en el archivo `my/simpleshirt.js`.
 
-Si el modulo posee dependencias, es posible especificarlas en el segundo argumento de `require.def()` a través de un arreglo) y luego pasar una función como tercer argumento. Esta función será llamada para definir el módulo una vez cargadas todos las dependencias. Dicha función recibe los valores devueltos por las dependencias como un argumento (en el mismo orden en que son requeridas en el arreglo) y luego la misma debe devolver un objeto que defina el módulo.
+Si el modulo posee dependencias, es posible especificarlas en el segundo argumento de `require.def()` a través de un vector) y luego pasar una función como tercer argumento. Esta función será llamada para definir el módulo una vez cargadas todos las dependencias. Dicha función recibe los valores devueltos por las dependencias como un argumento (en el mismo orden en que son requeridas en el vector) y luego la misma debe devolver un objeto que defina el módulo.
 
 
 **Definición de un módulo RequireJS con dependencias**
@@ -389,7 +389,7 @@ my/inventory.js
 my/shirt.js
 ```
 
-La función que define `my/shirt` no es llamada hasta que `my/cart` y `my/inventory` hayan sido cargadas, y dicha función recibe como argumentos a los módulos como `cart` y `inventory`. El orden de los argumentos de la función debe coincidir con el orden en que las dependencias se requieren en el arreglo. El objeto devuelto define el módulo `my/shirt`. Definiendo los módulos de esta forma, `my/shirt` no existe como un objeto global, ya que múltiples módulos pueden existir en la página al mismo tiempo.
+La función que define `my/shirt` no es llamada hasta que `my/cart` y `my/inventory` hayan sido cargadas, y dicha función recibe como argumentos a los módulos como `cart` y `inventory`. El orden de los argumentos de la función debe coincidir con el orden en que las dependencias se requieren en el vector. El objeto devuelto define el módulo `my/shirt`. Definiendo los módulos de esta forma, `my/shirt` no existe como un objeto global, ya que múltiples módulos pueden existir en la página al mismo tiempo.
 
 Los módulos no tienen que devolver un objeto; cualquier tipo de valor es permitido.
 
diff --git a/libro/markdown/cap11-eventos-personalizados.markdown b/libro/markdown/cap11-eventos-personalizados.markdown
@@ -123,7 +123,7 @@ Note como el comportamiento del interruptor general se ha vinculado al interrupt
 En el mundo de los eventos personalizados, existen dos métodos importantes de jQuery: `$.fn.on` y `$.fn.trigger`. En el capítulo dedicado a eventos se explicó la utilización de estos dos métodos para trabajar con eventos del usuario; en este capítulo es importante recordar 2 puntos:
 
 -   El método `$.fn.on` toma como argumentos un tipo de evento y una función controladora de evento. Opcionalmente, puede recibir información asociada al evento como segundo argumento, desplazando como tercer argumento a la función controladora de evento. Cualquier información pasada estará disponible a la función controladora a través de la propiedad `data` del objeto del evento. A su vez, la función controladora recibe el objeto del evento como primer argumento.
--   El método `$.fn.trigger` toma como argumentos el tipo de evento y opcionalmente, puede tomar un arreglo con valores. Estos valores serán pasados a la función controladora de eventos como argumentos luego del objeto del evento.
+-   El método `$.fn.trigger` toma como argumentos el tipo de evento y opcionalmente, puede tomar un vector con valores. Estos valores serán pasados a la función controladora de eventos como argumentos luego del objeto del evento.
 
 A continuación se muestra un ejemplo de utilización de `$.fn.on` y `$.fn.trigger` en donde se utiliza información personalizada en ambos casos:
 
diff --git a/libro/markdown/cap12-funciones-diferidas.markdown b/libro/markdown/cap12-funciones-diferidas.markdown
@@ -303,11 +303,11 @@ var isEven = function(number) {
     
 }
 
-// arreglo con una serie de números pares e impares
+// vector con una serie de números pares e impares
 var numbers = [0, 2, 9, 10, 5, 8, 12];
 
 // a través de deferred.pipe se pregunta si número se encuentra
-// dentro del arreglo numbers
+// dentro del vector numbers
 isEven(2).pipe(
     
     function(number){
@@ -329,7 +329,7 @@ isEven(2).pipe(
 ).then(
 
     function(){
-    	// al estar dentro del arreglo numbers y ser par,
+    	// al estar dentro del vector numbers y ser par,
     	// se registra este mensaje
         console.log('El número es par y se encuentra dentro de numbers');
     },

Original file line number	Diff line number	Diff line change
`@@ -676,7 +676,7 @@ $('ul').append('<li>item de la lista</li>');`
`676`	`676`
`677`	`677`	`> Nota`
`678`	`678`	`>`
`679`		-> La sintaxis para añadir nuevos elementos a la página es muy fácil de utilizar, pero es tentador olvidar que hay un costo enorme de rendimiento al agregar elementos al DOM de forma repetida. Si esta añadiendo muchos elementos al mismo contenedor, en lugar de añadir cada elemento uno por vez, lo mejor es concatenar todo el HTML en una única cadena de caracteres para luego anexarla al contenedor. Una posible solución es utilizar un arreglo que posea todos los elementos, luego reunirlos utilizando `join` y finalmente anexarla.
	`679`	+> La sintaxis para añadir nuevos elementos a la página es muy fácil de utilizar, pero es tentador olvidar que hay un costo enorme de rendimiento al agregar elementos al DOM de forma repetida. Si esta añadiendo muchos elementos al mismo contenedor, en lugar de añadir cada elemento uno por vez, lo mejor es concatenar todo el HTML en una única cadena de caracteres para luego anexarla al contenedor. Una posible solución es utilizar un vector que posea todos los elementos, luego reunirlos utilizando `join` y finalmente anexarla.
`680`	`680`
`681`	`681`
`682`	`682`	```javascript