No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

¿Qué es un array?

17/29
Recursos

Un array es una estructura de datos que permite almacenar una serie de datos localizados por índices y separados por comas.

Qué son los índices

El índice es la forma en que accedemos a los elementos de los arrays. En JavaScript, los índices empiezan desde 0, es decir, la primera posición es el índice 0. Un array se inicia mediante la sintaxis de corchetes [] y es tipo de dato objeto.

var array = [1,2,3,4]

Cómo acceder a los elementos del array

Para acceder a los elementos del array se utiliza la siguiente estructura:

array[índice]

Para saber la cantidad de elementos de un array se utiliza la propiedad length.

var array = [1,2,3,4]
var longitud = array.length
console.log(longitud) // 4

Ten en cuenta que la posición del elemento es diferente al índice del mismo.

Entonces, para acceder a un elemento del array, únicamente podrás utilizar los índices desde el 0 hasta array.length -1. Si se accede a un índice que no existe, devolverá undefined.

var nombres = ["Andres", "Ramiro", "Silvia"]

nombres[0] // "Andres"
nombres[1] // "Ramiro"
nombres[2] // "Silvia"
nombres[3] // undefined

Qué es la mutabilidad en los arrays

La mutabilidad hace referencia a la capacidad de una estructura de datos a cambiar. Esto permite cambiar los valores de los elementos de un array cuando accedemos a sus elementos mediante un índice.

Por ejemplo, cambiemos el segundo elemento con índice 1 al valor de “Platzi”:

var nombres = ["Andres", "Ramiro", "Silvia"]
// Accedemos y mutamos el segundo elemento
nombres[1] = "Platzi"

console.log(nombres) // ["Andres", "Platzi", "Silvia"]

Qué son los métodos de arrays

Los métodos de arrays son funcionalidades extra. Es semejante a las funciones, pero se accede mediante la notación punto array.metodo(argumentos).

Existen métodos mutables, es decir, que cambian el array original. Estos métodos son:

  • push
  • unshift
  • pop
  • shift

Cómo utilizar el método push

El método push agrega uno o varios elementos al final del array original. El método recibe como argumento los valores a agregar. Retorna el número de elementos del array mutado.

var array = [1,2,3]
array.push(4,5)
console.log(array) // [ 1, 2, 3, 4, 5 ]

Cómo utilizar el método unshift

El método unshift agrega uno o varios elementos al inicio del array original. El método recibe como argumento los valores a agregar. Retorna el número de elementos del array mutado.

var array = [3,4,5]
array.unshift(1,2)
console.log(array) // [ 1, 2, 3, 4, 5 ]

Cómo utilizar el método pop

El método pop extrae el elemento del final del array original.

var array = [1,2,3,4]
var lastElement = array.pop()
console.log(lastElement) // 4
console.log(array) // [ 1, 2, 3 ]

Cómo utilizar el método shift

El método shift extrae el elemento del inicio del array original.

var array = [1,2,3,4]
var firstElement = array.shift()
console.log(firstElement) // 1
console.log(array) // [ 2, 3, 4 ]

Cómo utilizar el método indexOf

El método indexOf muestra el índice del elemento especificado como argumento.

var array = [1,2,3,4]
var index = array.indexOf(2)
console.log(index) // 1

Si el elemento no se encuentra en el array, el método devuelve el valor -1.

var array = [1,2,3,4]
var index = array.indexOf("hola")
console.log(index) // -1

Contribución creada por Andrés Guano (Platzi Contributor).

Aportes 616

Preguntas 109

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

Lo que me hizo pensar esta clase … jajajajaj

Un Array es un tipo de estructura de datos, objeto. Puede guardar datos distintos dentro, guarda los datos en forma de lista.
.lenght devuelve la longitud del array.
.push() agrega elementos al final de array.
.pop() elimina un elemento del array.
.unshift() agrega un elemento al array, pero lo agrega en primer lugar.
**.shift() **elimina el elemento que está en el inicio del array.
**.indexOf ** devuelve la posición de un elemento del array.

Aqui unos ejemplos graficos de los metodos de arrays

Para complementar un poco, ya que me parece que en los otros cursos de JavaScript tampoco lo mencionan, a los arrays también se les pueden asignar o añadir datos con string keys, es decir, pasándole un string entre corchetes en vez del índice.

Algo curioso con los string keys es que no influye en la longitud de los arrays, por ejemplo:

Algunos dirán que si quiero usar string keys, ¿por qué no usar un objeto?
Pero la verdad es que dependiendo de lo que estés desarrollando podrías necesitar usar un array de esta forma y si quieres saber la longitud de un array tomando en cuenta las string keys, es posible hacerlo de la siguiente forma:

el .pop() elimina el último elemento del array y el .shift() elimina el primero , no es necesario pasarles un parametro

para el caso de arrays y objetos, un console.table() luce mejor que un clásico console.log() (chequen qué otros métodos se pueden utilizar, está genial!)

Esta es una buena documentación sobre javascript.
https://devdocs.io/javascript/

Les comparto una infografias donde se puede observar algunos de los metodos para clasificar y manipular los arrays

<h1>Mas elementos de arrays</h1>
var colores = [“rojo”, “azul”, “verde”, “amarillo”];
  1. Reverse, metodo que establece que el array invierte los elementos
colores.reverse();
["amarillo", "verde", "azul", "rojo", "anaranjado"]
  1. Sort, metodo para ordenar alfabeticamente los array con datos de tipo String
colores.sort();
["amarillo", "anaranjado", "azul", "rojo", "verde"]
  1. Slice, método que puede contener uno o dos argumentos, que indiquen el inicio y parada de posiciones, pues devuelve los elementos contenidos en el array, de acuerdo a los argumentos indicados, por ejemplo si a colores, le agregamos colores.slice(1,3); obtendremos los que se encuentran en la posición 1, 2
colores =  ["amarillo", "anaranjado", "azul", "rojo", "verde"]
colores.slice(1,3);
["anaranjado", "azul"]

Si solo se indica un argumento se tomará como inicio ese argumento y como final la última posición, entonces si usamos:

colores.slice(2);
["azul", "rojo", "verde"]

en este link pueden encontrar mas documentacion

var frutas = ["Manzana", "Plátano", "Cereza", "Fresas"];

console.log(frutas);

console.log(frutas.length); // lingitud o numero de elementos
console.log(frutas[n]); // acceder al elemento por medio de index

//Mutar o alterar Array
var masFrutas = frutas.push("Uvas") //añadir elementos al final del array
var ultimo = frutas.pop()//Eliminar el último elemento del Array
var nuevaLongitud = frutas.unshift("Uvas");//añadir elemento al inicio del array
var borrarFruta = frutas.shift("Uvas");//Borrar elemento
var posicion = frutas.indexOf("Cereza");//Devuelve el index o posicion del elemento```


Por ende los métodos shift y pop no es obligatorio pasarles parametros

Array tiene los siguientes metodos:

  • .push : Añade un elemento al final del array.
  • .pop : Elimina un elemento del final del array
  • .unshift : Añade al inicio
  • .shift : Elemina del inicio
  • .indexOf : posicion del elemento

Se esta cometiendo un error en el video ya que no se esta enseñando de forma correcta el uso de los métodos .pop() y .shift(), para eliminar un elemento al final o al inicio del array no es necesario especificar cual es, con simplemente llamar los métodos es suficiente. Esto podría confundir a los estudiantes cuando vean el código de otras personas o inclusive documentación en paginas como Developer Mozilla o W3Schools.

Creo que para esta clase también es importante aclarar que existen mas atributos que mutan a un array, yo considero igualmente importante el método splice() el cual cambia el contenido de un array eliminando elementos existentes y/o agregando nuevos elementos.

Supongamos que deseamos eliminar el indice [2] o cual quier otro indice que no sea el primero o el ultimo ya que para esto podríamos usar pop() para el ultimo y shift() para el primero, podríamos emplear el siguiente método de la siguiente manera

var removed = frutas.splice(2,1)

en este caso el numero 2 representa el numero del index mientras tanto el 1 el numero de indices que eliminaras a partir del index indicado, en otras palabras, nos indica que eliminara solo un index a partir del index dos
Si desean ver mas información acerca de este y de todos los atributos que nos ayudan a la manipuladores de los arrays pueden ver la siguiente documentación

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array

Resumen

// Estructura de datos --> tipo objeto --> guarda mas valores adentro
//Puede guardar numero,string, objetos, incluso otros arrays esto se conoce como estructura de datos

// Sintasix
var frutas = ["Manzana", "Platano", "Fresa"];

// Estos elementos se separan por coma,
//podemos llamar a todo nuestro objeto que internamente tiene elementos

console.log(frutas); // me mostrar todo el array y sus elementos

// Podemos versu longitud osea cuantos elementos tengo dentro de este array

console.log(frutas.length); // con len sabemos cuantos elemntos hay en el array

// Para acceder a un elemento en especifico en el array

console.log(frutas[0]);

// Recordemos que el index del array arranca en 0, si queremos llegar a fresa seria 2

// Cuando hablamos de arrays hablamos de 2 metodos mas comunes

//Estos metodos nos ayudan a generar cosas con los arrays
// 1 es agregar elementos
//Sintaxis

var masFrutas = frutas.push("Uvas"); // Añade lun elemento al final del array

// Ahora si queremos quitar un elemento

var quitarFruta = fruta.pop("Uvas");

// Para agregar un elemento al array pero al principio, parecido a .push pero al inicio

var nuevaFruta = fruta.unshift("Uvas");

// Ahora para eliminar un elemento al inicio

var borrarFruta = fruta.shift("Uvas");

// De igual manera asi no pongamos el string y usamos shift se borrara el 1re elemento

// Podemos saber la posicion de un melemento del array tan solo con su nombre en string

//Ejemplo

var posicion = frutas.indexOf("Fresa");

console.log(posicion);

Mi aporte



//Forma sintaxica de generar un array
var frutas = ["Manzana", "Plátano", "Cereza", "Fresa"];
console.log(frutas);
console.log(frutas.length); //Para ver tamaño del array
console.log(frutas[0]); //Consultar un elemento del array en posición especifica

//Metodos que nos ayudan a mutar un array
//Agregar más frutas al final de nuestro array
var masFrutas = frutas.push("Uvas");
//Eliminar ultimo elemento del array
var ultimo = frutas.pop("Uvas");
//Agregar al inicio de nuestro array
var nuevaLongitud = frutas.unshift("Uvas");
//Borrar primer elemento del array
var borrarFruta = frutas.shift("Manzana");
//Nos ayuda a saber la posición del elemento que le pasemos al array
var posicion = frutas.indexOf("Cereza");

wow muchos estudiantes de aqui viendo sus comentarios/desafios andan ya mas avanzados jaja. Esperense un poquito, apenas vamos gateando jeje.

Instructor la manera en que explica me parece genial. Me gusta repetir las clases porque siempre hay cosas que paso por alto y al revisarlas de nuevo descubro algo nuevo.

No entiendo para qué se lo coloca entre comillas el nombre de “Manzana” o de “Cerezas” si igualmente se borrará el que esté de primero en el caso de .shift osea, qué sentido tiene ponerle eso?

ufff, venia complicada con todos los temas pero arrays es el tema que entendi mas rapido jajaja
Dejo un enlace: https://www.w3schools.com/js/js_array_methods.asp

Parece ser que los métodos pop y shift no necesitan parámetros para eliminar el último y el primer elemento de un array (segun el caso). Basta con:

var ultimo = frutas.pop()
var borrarFruta = frutas.shift()

Fuentes:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift

Me estoy dando cuenta que el método pop() siempre elimina el ultimo elemento del array sin importar cual yo le ponga dentro de los paréntesis…Es así o estoy equivocado?

array.push => agrega un elemento al final del array
array.pop => elimina un elemento del final de un array
array.unshift => agrega un elemento al inicio del array
array.shift=> elimina un elemento del inicio de un array
array.indexOf => nos indica la posicion de un elemento en el array

 Arrays:
 Podemos usar diferentes operaciones
   => push("elemento") pone en [length]
   => pop() quita en [length]
   => unshift() poner en [0]
   => shift() quitar de [0]
   => indexOf("Pera") Busca un elemento y
   => retorna la posicion en el array.

Esta clase está muy bien explicada, esta es la manera correcta de enseñar-

Hola a todos, les comparto mi resumen:

Arrays
Los Array son estructuras de datos o también llamados Listas el cual almacena varios datos en un mismo lugar los cuales pueden ser de cualquier tipo ya sea string, numero, objetos, etc.

Index de Arrays
El index es el indicador de donde se encuentra ubicado un elemento dentro de un Array, inicia a partir del 0.

Métodos de los Arrays
Los métodos nos ayudan a manipular los elementos dentro de los Arrays.

Algunos de los métodos en los arrays son lo siguientes:

  • .push - Este método lo que hace es agregar un nuevo elemento al final del array.
  • .pop - Este método elimina el último elemento dentro de un array.
  • .unshift - Este método agrega un nuevo elemento al inicio del array y recorriendo el index de todos los elementos.
  • .shift - Este método elimina el primer elemento dentro de un array.
  • .indexOf - Este método nos dice en que index se encuentra un elemento dentro del array.

Las funciones de pop y shift no requieren que escribas algo entre paréntesis, pues su función es eliminar el primer elemento o el último elemento del array, es más fácil si no lo escribes.

Yo aprendi arrays en C, fue una pesadilla.

🤔 Es indispensable tener conocimientos de estructura de datos.

// ARRAYS MÉTODOS //

// push: Coloca un elemento al final del Array
    //frutas.push('elemento')

//pop: Elimina el último elemento del Array
    // frutas.pop()

//unshift: coloca un elemento al comienzo del Array
    //frutas.unshift('elemento');


//shift: Elimina el primer elemento del Array   
    // frutas.shift()

// indexOf: indica la posición del elemento
    //frutas.indexOf('elemento' Ej:'Cereza')

Aquí algunas notas de la clase:
.

.
Espero que sean de su utilidad.
(⌐■_■)

El objeto Array de JavaScript es un objeto global que es usado en la construcción de arrays, que son objetos tipo lista de alto nivel.

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array

un arreglo o un array, es una estructura de datos que se almacena Bajo el mismo nombre a una colección de datos. es decir, cuando nosotros declaramos un arreglo, estamos abriendo un espacio en memoria al igual que lo hacemos con las variables, pero con la diferencia de que un arreglo está seccionado o dividido en varias partes. los arreglos Se caracterizan por: en primer lugar, almacenar los elementos en posiciones contigua de memoria, es decir, los elementos están uno al lado del otro, tienen un mismo nombre de variable que representa a todos los elementos. los elementos, son asignados a una posición dentro del vector y los arreglos trabajan en conjunto con índices que especifican la posición de cada elemento dentro del arreglo.

  • .lenght devuelve la longitud del array.

  • .push() agrega elementos al final de array.

  • .pop() elimina un elemento del array.

  • .unshift() agrega un elemento al array, pero lo agrega en primer lugar.

  • .shift() elimina el elemento que está en el inicio del array.

  • .indexOf devuelve la posición de un elemento del array.

me mata como cambia todo el tiempo el nombre.“Array” “Arrail”

Arrays

var languages = [“Javascript”, “C#”, “C”]

  • Para saber cuántos elementos tiene un array:
    languages.length

  • Para acceder a un elemento de un array:
    languages[index] => languages[0]

  • Para agregar un elemento al final de un array:
    languages.push(“Javascript”)

  • Para agregar un elemento al inicio de un array:
    languages.unshift(“Javascript”)

  • Para eliminar el primer elemento de un array:
    languages.shift(“Javascript”)

  • Para eliminar el último elemento de un array:
    languages.pop(“Javascript”)

  • Para obtener la posición de un elemento:
    languages.indexOf(“C#”);

push = nuevo elemento al final del arreglo
pop = eliminar ultimo elemento
unshift = agregar como primero elemento
shift = eliminar primer elemento
indexOf = saber posición de elemento

Son una estructura de datos. Es un valor que va a guardar mas valores adentro y estos valores pueden ser strings, objetos o números.

Para crear un array utilizamos:

var Frutas = [];

Se genera una variable, porque para acceder a un valor de esta, se hace desde el nombre. Para poder declarar datos dentro de este array, se hace de la siguiente forma:

var Frutas = ["manzana","pera","platano"];

Y como accedemos a estos datos?

Al momento de querer seleccionar uno, tenemos que poner el nombre de la variable y entre corchetes su posición, recordando que en programación se empieza a contar desde 0. Esto se muestra asi:

console.log(Frutas[1]); --> "pera"

Para saber cual es la longitud del Array hay que usar el método

Frutas.legth();

Existen otros métodos que nos ayudan a cambiar cosas del Array:

- Frutas.push("Uvas");  → Este método sirve agregar al final de nuestro arreglo un nuevo elemento.
- Frutas.pop("Uvas"); → Este metodo eliminara el ultimo elemento agregado al array.
- Frutas.unshift("Uvas"); → Este método agregara algo a nuestro Array PERO lo hara al principio.
- Frutas.shift("Uvas"); → Este metodo es para eliminar el primer elemento posicionado en el array.
- Frutas.indexOf("Platano"); → Este método nos devolverá el índice de un elemento en el Array.

Por qué el profesor los pronuncia como Arrayls?

Arrays
Mis apuntes, espero les sirvan.
Un Array es una estructura de datos y tipo de objeto, es un valor que va a guardar mas valores adentro, puede ser, string, número, hasta un Array dentro de un Array. El Array es una lista de datos que va a guardar ciertos valores, para generar un Array generamos una variable y el valor de la variable va a ser el Array, generamos una variable para cuando queramos acceder alguno de sus valores. Para generar el Array ponemos unos corchetes [] y dentro del corchete ponemos los datos que queremos y cada elemento es separado por una coma.

var frutas = ["Manzana", "Plátano", "Cereza", "Fresa"];

Si queremos conocer el contenido de un Array podemos usar .length, podemos cuantos elementos tiene el Arrays

console.log(frutas.length);
// 4

En programación la cuenta inicia con un 0, siempre el primer elemento de un Array inicia en la posición 0. Para acceder a un elemento del Array llamamos a nuestro Array y en el paréntesis ponemos el número de su posición.

console.log(frutas[0]);
//"Manzana"

Si queremos llegar a Fresa ponemos 3

console.log(frutas[3]);
// "Fresa"

Cuando usamos Arrays tenemos métodos que nos ayudan a poder generar cosas con los Arrays, tenemos:

  • .push: Añade elementos al final del Array, siempre se vera al final del Array

    var frutas = ["Manzana", "Plátano", "Cereza", "Fresa"];
    var nuevaFruta = frutas.push("Uva");
    console.log(frutas);
    "Manzana", "Plátano", "Cereza", "Fresa", "Uvas"
    
  • .pop: Elimina el último elemento del Array (No es necesario pasar el elemento parámetro en el paréntesis)

    var borrarFruta = frutas.pop("Uvas");
    
  • .unshift: Nos agrega un elemento a nuestro Array pero al inicio. Un ejemplo de uso es que hay una fiesta y hay una lista VIP, de último momento el invitado más importante te confirma que si va y tiene que ser el primero en entrar.

    var masFrutas = frutas.unshift("Mango");
    console.log(frutas);
    "Mango", "Manzana", "Plátano", "Cereza", "Fresa"
    
  • .shift: Nos ayuda a eliminar el primer elemento del Array, igual no es necesario pasarle parámetro

    var adiosFruta = frutas.shift("Mango");
    console.log(frutas);
    "Manzana", "Plátano", "Cereza", "Fresa"
    
  • .indexOf: Nos ayuda a saber la posición de un elemento

    var posicion = frutas.indexOf("Cereza");
    console.log(posicion);
    //2
    
  • .reverse: Invierte los valores de los elementos

    var alreves = frutas.reverse();
    console.log(alreves);
    //"Fresa", "Cereza", "Plátano", "Manzana"
    
  • .sort : Ordena alfabéticamente los elementos

    var colores = [“rojo”, “azul”, “verde”, “amarillo”];
    colores.sort();
    ["amarillo", "anaranjado", "azul", "rojo", "verde"];
    

Con el único que hay que tener cuidado es con shift, este puede borrar todo tu array ya que si no ejecutas unshift previamente todo el array es eliminado en su lugar.

var comida = ["Carne, Leche, Pan, Nata, Queso"];
console.log("Array: " + comida);
comida.push(" Jamón");
console.log("Push: " + comida);
comida.pop();
console.log("Pop: " + comida);
comida.unshift("Tacos");
console.log("Unshift: " + comida);
comida.shift();
console.log("Shift: " + comida); //shift borrará TODO el array si se ejecuta antes de unshift

Un array es un tipo objeto y además una estructura de datos: Un valor que va a guardar más valores adentro: Números, strings, objetos o más arrays. (siempre y cuándo todos sean del mismo tipo. Gracias Jeferson Velázquez).

Ejemplo:

var frutas = ["Manzana", "Plátano", "Cereza", "Fresa"];

console.log(frutas);
(4) ["Manzana", "Plátano", "Cereza", "Fresa"]
//entonces arroja el número de items y el contenido de cada uno

Si queremos saber la extensión del array

console.log(frutas.length);
4

Para conocer un elemento aislado del array:

console.log(frutas[0]);
Manzana

Observe que en programación se comienza desde el 0. Por tanto, Manzana es 0, Plátano es 1, Cereza es 2 y Fresa es 3.

Métodos para mutar un array:

//.push · Agrega un elemento al final del array.
var masFrutas = frutas.push("Uvas");

//Por lo tanto, si volvemos a consultar el contenido de Frutas, sucede esto:
frutas
(5) ["Manzana", "Plátano", "Cereza", "Fresa", "Uvas"]

//.pop elimina el último
var sacarUltimo = frutas.pop("Uvas");
frutas
(4) ["Manzana", "Plátano", "Cereza", "Fresa"]

//.unshift agrega elementos al principio
var nuevaLongitud = frutas.unshift("Piña");
frutas
(5) ["Piña", "Manzana", "Plátano", "Cereza", "Fresa"]

//.shift elimina el elemento al inicio
var borrarFrutaInicial = frutas.shift("Piña")
frutas
(4) ["Manzana", "Plátano", "Cereza", "Fresa"]

//.indexOf Para saber en qué posición está el elemento
var posición = frutas.indexOf("Cereza");
//Consultamos
posicion
2

Observe que para .push y para .shift el elemento de referencia debe coincidir con el que efectivamente se encuentre en ese lugar. Si escribimos “Cereza” para eliminar el primero y el primero NO es cereza, no sucederá nada.

Les comparto una Conclusión 😃

.push(); agrega un dato al final del array.
.pop(); quitar el último dato del array (agregado).
.unshift(); agregar un dato al principio de la lista (con prioridad) por así decirlo.
.shift(); quitar el primer dato del array (agregado),
.indexOf ver para saber la posición de un dato del array (de mucha ayuda si el array es demasiado extenso).

Espero les ayude, suerte!

Métodos para transformar arrays:

  • push: agrega elemento al final
  • pop: borra elemento del final.
  • unshift: agrega elemento al inicio.
  • shift: borrar elemento del inicio del array.
  • indexOf: devuelve el index del elemento enviado como parámetro.

pop elimina el ultimo elemento del array
push agrega elementos a un array
unshift agrega elementos a un array pero en primera posición
shift elimina el primer elemento de un array
indexof obtienes el index del elemento

var frutas = ["manzana", "banano", "cereza", "papaya"];

console.log(frutas.length) // cantidad de objetos dentro de la variable

console.log(frutas[0]); // acceder a un elemento dentro del arreglo de acuerdo a su posición

var masFrutas = frutas.push("uvas");   // añadir elementos al final

console.log(frutas);

var ultimo = frutas.pop();  // eliminar el último elemento

console.log(frutas);

var nuevaLongitud = frutas.unshift("melón")  // agregar un nuevo elemento al inicio

console.log(frutas);

var borrarFruta = frutas.shift()  // eliminar el primer objeto

console.log(frutas);

var posicion = frutas.indexOf("banano");

console.log(posicion); // ubicar la posición numérica de un elemento

frutas[3]; // traer el nombre desde la posición```

Es posible añadir varios elementos dentro de las funciones unshift() y push()

frutas.unshift("piña", "guanabana");
frutas.push("piña", "guanabana");

Con array.pop() elimino el último elemento del array.
Con array.shift() elimino el primer elemento del array.

¿Hay forma de eliminar un elemento en medio del array?

Yo conocia los Arrays pero no los arrails

¿A alguien más le hace ruido que diga “arrails” en vez de “arrays”? Me desconcentra mucho eso

Asi lo hice yo, con explicacion incluida para reafirmar:

var paises = ['Argentina', 'Chile', 'Peru', 'Bolivia'];

//Agrega Meico al array
var masPaises = paises.push(
    'Mexico'
);

//Nombra a Mexico
console.log(paises[4]);

var last = paises.pop('Mexico');

//Muestra todos los paises con Mexico borrado
console.log(paises);

var newPais = paises.unshift('Colombia');

//Muestra todos los paises con Colombia agregado primero
console.log(paises);

//Te dice la posicon de Argentina en el array 
console.log(paises.indexOf('Argentina'));


Hola, Diego. Por qué el string “Colombia” se comporta como un array.

Los arrays son matrices, recien me doy cuenta.

Cabe acotar que cuando usas el array.pop() , elimina el ultimo elemento del array, pero si usas array.pop(“nombre_elmento_cualquier posicion”), eliminara el elemento descrito sin importar que sea el último.

Un Array es un tipo de estructura de datos, objeto. Puede guardar datos distintos dentro, guarda los datos en forma de lista.
.lenght devuelve la longitud del array.
.push() agrega elementos al final de array.
.pop() elimina un elemento del array.
.unshift() agrega un elemento al array, pero lo agrega en primer lugar.
**.shift() **elimina el elemento que está en el inicio del array.
**.indexOf ** devuelve la posición de un elemento del array.

Espero les sirva el siguiente resumen, añadí información sobre casos de uso más comunes para métodos más complejos de entender

var frutas = ["Naranjas","Mangos","Manzanas","Sandias"];
console.log(frutas);

//Aniade un elemento al final del array
var addLastFruit = frutas.push("Uvas");
console.log(frutas);

//Elimina el ultimo elemento del array
var deleteLastFruit = frutas.pop();
console.log(frutas);

//Aniade un elemento al principio del array
var addFirstFruit = frutas.unshift("Platanos");
console.log(frutas);

//Elimina el primer elemento del array
var deleteFirstFruit = frutas.shift();
console.log(frutas);

//muestra el index del elemento del array
var showIndexFruit = frutas.indexOf("Mangos");
console.log(showIndexFruit);

//Une los elementos de dos arrays en uno
var frutas1 = ["Naranjas","Mangos"];
var frutas2 = ["Manzanas","Sandia"];
var uneTodasLasFrutas = frutas1.concat(frutas2);
console.log(uneTodasLasFrutas);

//ordena los elementos de un array en orden ascendiente
var orderAscFruit = frutas.sort()
console.log (orderAscFruit);

//ordena los elementos de un array en orden descendiente
var orderDescFruit = frutas.reverse();
console.log(orderDescFruit);

// Ejemplo de map()
/*
map() es un método muy útil en una variedad de situaciones, y es especialmente útil cuando se trata de transformar los elementos de un array. Aquí hay algunos casos comunes en los que puedes usar map():
1.- Transformar los elementos de un array: Puedes usar map() para transformar los elementos de un array, como convertir números a strings, aplicar una función matemática a cada elemento, o calcular un valor a partir de los valores de cada elemento.
2.- Crear un nuevo array a partir de un array existente: Puedes usar map() para crear un nuevo array a partir de un array existente, como filtrar un array para incluir solo ciertos elementos o duplicar los valores de un array.
3.- Normalizar los datos de un array: Puedes usar map() para normalizar los datos de un array, como convertir temperaturas de grados Celsius a grados Fahrenheit o convertir fechas a un formato determinado.
4.- Convertir un objeto en un array: Puedes usar map() para convertir un objeto en un array, como extraer las claves de un objeto y almacenarlas en un nuevo array.
*/
/*
map() es un método que se usa para transformar los elementos de un array. La función que se proporciona a map() se invoca para cada elemento del array, y el resultado de cada invocación se almacena en un nuevo array.
En este ejemplo, estamos transformando cada elemento del array numeros en su doble, y almacenando los resultados en un nuevo array llamado dobles.
La función que se proporciona a map() es numero => numero * 2. Esta función toma un argumento numero, que es el elemento actual del array numeros que se está procesando en ese momento. La función devuelve numero * 2, que es el doble del elemento actual.
Por lo tanto, en la primera iteración, la función se invoca con numero igual a 1. La función devuelve 1 * 2 = 2, y este valor se agrega al nuevo array dobles. En la siguiente iteración, la función se invoca con numero igual a 2. La función devuelve 2 * 2 = 4, y este valor también se agrega al nuevo array dobles. Este proceso continúa hasta que se han procesado todos los elementos del array numeros, y el resultado final es un nuevo array dobles que contiene los resultados de todas las invocaciones de la función.
*/
const numeros = [1, 2, 3, 4];
const dobles = numeros.map(num => num * 2);
console.log(dobles); // [2, 4, 6, 8]

// Ejemplo de filter()
const numeros = [1, 2, 3, 4, 5, 6];
const pares = numeros.filter(num => num % 2 === 0);
console.log(pares); // [2, 4, 6]

// Ejemplo de concat()
const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const array3 = array1.concat(array2);
console.log(array3); // [1, 2, 3, 4, 5, 6]

// Ejemplo de slice()
const frutas = ['banana', 'manzana', 'pera', 'mango', 'kiwi'];
const frutasVerdes = frutas.slice(2, 4);
console.log(frutasVerdes); // ['pera', 'mango']

// Ejemplo de splice()
const frutas = ['banana', 'manzana', 'pera', 'mango', 'kiwi'];
frutas.splice(2, 1, 'fresa');
console.log(frutas); // ['banana', 'manzana', 'fresa', 'mango', 'kiwi']

// Ejemplo de reduce()
/*
reduce() es un método muy versátil y útil en una variedad de situaciones, y es especialmente útil cuando se trata de procesar y reducir un array a un solo valor. Aquí hay algunos casos comunes en los que puedes usar reduce():
1.- Sumar o multiplicar todos los elementos de un array: Puedes usar reduce() para calcular la suma o el producto de todos los elementos de un array.
2.- Contar la cantidad de elementos en un array que cumplen cierta condición: Puedes usar reduce() para contar cuántos elementos en un array cumplen una determinada condición.
3.- Concatenar todos los elementos de un array en una sola cadena: Puedes usar reduce() para concatenar todos los elementos de un array en una sola cadena.
4.- Calcular el máximo o el mínimo de un array: Puedes usar reduce() para calcular el valor máximo o mínimo de un array.
5.- Calcular la media o la mediana de un array: Puedes usar reduce() para calcular la media o la mediana de un array.
*/
/*
En el ejemplo de reduce(), la función proporcionada toma dos argumentos: acumulador y valorActual.
acumulador es un valor acumulativo que se va actualizando a medida que se procesan los elementos del array. El valor inicial del acumulador es el valor especificado en el segundo argumento de la función reduce().
valorActual es el valor actual del elemento del array que está siendo procesado en ese momento.
En cada iteración de la función reduce(), la función proporcionada es invocada con el acumulador y el valorActual actual, y el resultado de esa invocación se asigna a acumulador. Así, el acumulador va acumulando el resultado de todas las invocaciones de la función hasta que se han procesado todos los elementos del array.
*/
const numeros = [1, 2, 3, 4];
const suma = numeros.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
console.log(suma); // 10

Consejo del día: tomen sus apuntes directamente en el visual y no ocupen de otra cosa para no distraerse. 😃

Las propiedades de .pop() y de .shift() se pueden utilizar sin necesidad de poner el valor del objeto que queremos eliminar dentro de los paréntesis.

Mientras observaba la clase, si bien es cierto se vieron varios métodos, tanto para eliminar el primero como el último elemento, pero y si deseas eliminar un elemento ya sea que este situada quizá en el medio o casi al final del Array, entonces al hacerme esta pregunta me puse a investigar un poco y me encontré de que si querías eliminar o agregar un elemento usando de referencia el índice, se usa el método splice.
EJEMPLO :

y si en el caso hipotético que yo colocara 2 en el índice subrayado de color amarillo, quiere decir que eliminaría el elemento pera y plátano, por lo que llegamos a la conclusión de que el índice subrayado de amarillo determina la cantidad a eliminar después de la posición colocada en el primer índice.

Si no quedo claro, les dejo el link donde te dan ejemplos de como usar el método splice para agregar y eliminar elementos.
https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

.push = agrega elemento al ultimo lugar
.pop = elimina al elemento del ultimo lugar
.unshift = agrega elemento en el primer lugar
.shift = elimina al elemento del primer lugar

Quiero hacer un pequeño aporte para los nuevos que van llegando. Los métodos que eliminan items del array (pop, shift) no es necesario que pasen algún valor como parámetro, es decir. Hacer frutas.pop(‘Uvas’) es lo mismo que hacer frutas.pop(). Lo mismo pasa con el metodo shift. Adicionalmente, estos métodos retornan (devuelven) el valor que se esta eliminando del array. Ya depende de ti si dicho valor lo guardas o lo pierdes. No es obligatorio que siempre que uses pop o shift uses una variable para almacenar el dato que retorna. Adicionalmente, no use var. Empiecen a usar let y const que son los estándares para ES6.

Comparto mis apuntes 😁

//crear array
var frutas = ["manzana", "platano", "cereza", "fresa"];

//ver array
console.log(frutas);

//ver cuantos elementos tiene
console.log(frutas.length);

//Accdeder a elementos del array
console.log(frutas[0]); //Retorna manzana

//Agregar elementos al final del array
var masFrutas= frutas.push("uvas");

//Borrar ultimo elemento del array
var ultimo = frutas.pop("uvas");

//Agregar elementos al principio del array
var nuevaLongitud = frutas.unshift("uvas");

//Borrar primer elemento del array
var borrarFruta = frutas.shift("uvas");

//Saber la posion de un elemento del array
var posicion =frutas.indexOf("cereza");```

Es tipo objeto porque puede guardar varios valores adentro de todo tipo, aunque los valores que se guarden en el array deben de ser del mismo tipo.

  • Sintaxis

var nameArray[“dato”,“dato”];

  • Métodos

En los arrays tenemos algo llamado métodos que básicamente su función sera ayudar a manipular los datos dentro del array

  • Sintaxis de un método

var name = nameArray.metodo(dato si se requiere);

  • Ejemplos métodos

.lenght

devuelve la longitud del array, ósea cuantos datos hay.

.push()

agrega elementos al final de array.

.pop()

elimina un elemento del final del array.

.unshift()

agrega un elemento al array, pero lo agrega en primer lugar.

.shift()

elimina el elemento que está en el inicio del array.

.indexOf

devuelve la posición de un elemento del array.

Notas de clase

  • Son objetos, es decir de tipo de dato no primitivo (como el string o number).

  • Pueden guardar más de un valor de diferente tipos de dato ( primitivo o no).

  • Son estructuras de datos del tipo lista.

  • Las variables pueden aumentar y disminuir su tamaño, son mutables.

  • Los elementos principales en un array son el índice y su valor ( elemento)

var ultimaFruta = frutas.pop(); //Elimina el ultimo y devuelve el elemento eliminado.

Cuando se usa el método **POP ** no hay necesidad de poner entra comillas el dato. Se ponen los paréntesis vacíos.
Algunas veces no sabemos cual es el ultimo dato (se puede descubrir pero a veces no necesitamos) por eso solo eliminamos.

var ultimo = frutas.pop();

De igual forma para el shift:

var borrarFruta = frutas.shift();

¡Hola a todos! Les comparto también mis notas de esta clase, espero les sean de utilidad 😃

Resumen de la clase:

Les comparto mis anotaciones para esta clase.

Metodos
//push añade elementos al final de mi array
//pop elimina un elemento del array
//unshift agrega un elemento al inicio
//shift elimina el primer elemento
//indexOf() nos dice la posición de un elemento en el array

Los array son muy importantes de entender asi que hice un monton de notas que espero les sirvan:

// Clase: Array
//
//Los array puden ser conjuntos de datos o mejor llamados 'listas'
//estas listas nos permiten agrupar grandes cantidades de data en una unica
//variable a la cual podemos acceder despues
//

var listaDeMercado = ["arroz", "carne", "verduras", "aguacate"];

//cada lista sera definida y contenida dentro de los []
//para acceder a cada 'posicion' de lista lo haremos usando indices
//y en JS es bien conocido que la primera posicion de una lista es siempre el '0'

console.log(listaDeMercado[0]) //arroz
console.log(listaDeMercado[1]) //carne
console.log(listaDeMercado[2]) //verduras

//RETO: Como saber cuantas cosas tienes en tu 'lista de mercado'?
//para eso usamos una propiedad que nos dice le largo de la lista

console.log(listaDeMercado.length); //4


//RETO: a tu mama se le olvido agregar el "azucar", como lo puedes agregar al final?
//para este ejemplo crearemos una nueva lista y 'empujaremos' el "azucar" a la
//ultima posicion de nuestro array

listaDeMercado.push("azucar");

//tu mama olvido que en la casa hay 'azucar' ahora hay que quitarla de la lista

listaDeMercado.pop();

//RETO: Tu mama te dice que lo primero que debes comprar es la leche
//agregala de primero antes de que se acabe

listaDeMercado.unshift("leche")



//Como eliminar el primer elemento?

listaDeMercado.shift("leche") ```

Aporte:
Para eliminar cualquier elemento de un array, sabiendo el valor, incluso si esta repetido :

Por ejemplo si quiero eliminar ‘melon’

frutas.filter( function(x){
	if(x != 'melon') return x
 });

Ya que vi varios comentarios sobre el tema, me gustaría dejar un ejemplo de porque cuando pone “manzana” dentro de pop(), no cambia nada.
Pop es un método, es como una función, pero de una clase. Estos pueden permitir el uso de parámetros o no, que se declaran dentro de los paréntesis como ya vimos, pero si la función o método no usa parámetros, y nosotros se los colocamos igual, directamente los ignora.
Dejo screen para que sea mas fácil de visualizar, y el código para que lo prueben ustedes mismos.
Saludos.

function ejemplo(){
    console.log("hola mundo");
}

ejemplo("manzana");

Entender qué o como funciona un Array es sencillo, lo complicado es aprenderse todas las funciones que ofrece Javascript ajaja

A los métodos

.pop()
.shift()

NO es necesario pasarle los parámetros. EN REALIDAD NO SE LE PASAN parámetros. Estos métodos asumen que:

  • Eliminará el último elemento (.pop)
  • Eliminará primer elemento (.shift)

Resumen

Arrays

Son un tipo de estructura de datos, objeto. Puede guardar datos de distintos tipo dentro (aunque no en el mismo espacio), guarda los datos en forma de lista. Puede guardar Strings, números, Otros Arrays, etc…

Para Crear un array se puede crear una variable en la que se le asigna el Array utilizando [ ].

Por ejemplo:

var frutas = ["Manzana", "Banana", "Cereza", "Fresa"];

Para conocer la cantidad de elementos que hay en un Array utilizamos .lenght que devuelve la longitud del Array.

console.log(frutas.length);
4

Para acceder a un elemento del Array se utiliza el número de su posición en la lista. Pero algo a tener en cuenta es que en programación la cuenta no empieza desde el 1 sino desde el 0. Es decir que el primer elemento del Array se va a identificar siempre con la posición [0]. Por ejemplo:

console.log(frutas [0]);
"Manzana"
console.log(frutas [1]);
"Banana"
console.log(frutas [2]);
"Cereza"
console.log(frutas [3]);
"Fresa"

Hay métodos que se pueden utilizar para agregar o quitar elementos en un Array.

Con .push() se agregan elementos al final de array.

Con .pop() se eliminan elementos al final del array.

Con .unshift() se agregan elementos al inicio del array.

Con .shift() se eliminan elementos al inicio del array.

Por ejemplo:

Si queremos agregar una nueva fruta al final del Array usamos .push().

var frutas = ["Manzana", "Banana", "Cereza", "Fresa"];
var masFrutas = frutas.push("Uvas");
//Ahora se agregó "Uvas" al Array frutas al final de la lista.
console.log(frutas);
(5) ["Manzana", "Banana", "Cereza", "Fresa", "Uvas"]
//Ahora "Uvas" ocupa la posición [4].

Si quisieramos eliminar el último elemento de la lista (en éste caso “Uvas” en la posición [4]) utilizamos pop().

var frutas = ["Manzana", "Banana", "Cereza", "Fresa", "Uvas"];
var ultimo = frutas.pop("Uvas");
//Ahora se eliminó "Uvas" del Array frutas desde el final de la lista.
console.log(frutas);
(4) ["Manzana", "Banana", "Cereza", "Fresa"]
//Ahora "Uvas" ya no aparece en el Array.

Si quisieramos agregar una nueva fruta al inicio del Array usamos .unshift().

var frutas = ["Manzana", "Banana", "Cereza", "Fresa"];
var nuevaLongitud = frutas.unshift("Uvas");
//Ahora se agregó "Uvas" al Array frutas al inicio de la lista.
console.log(frutas);
(5) ["Uvas", "Manzana", "Banana", "Cereza", "Fresa", "Uvas"]
//Ahora "Uvas" ocupa la posición [0].

Si quisieramos eliminar el primer elemento de la lista (en éste caso “Uvas” en la posición [0]) utilizamos .shift().

var frutas = ["Manzana", "Banana", "Cereza", "Fresa", "Uvas"];
var borrarFruta = frutas.shift("Uvas");
//Ahora se eliminó "Uvas" del Array frutas desde el inicio de la lista.
console.log(frutas);
(4) ["Manzana", "Banana", "Cereza", "Fresa"]
//Ahora "Uvas" ya no aparece en el Array.

Si necesitamos un elemento y conocemos el contenido del Array pero desconocemos su posición podemos utilizar .indexOf que devuelve la posición de un elemento del array.

var frutas = ["Manzana", "Banana", "Cereza", "Fresa"];
var posicion = frutas.indexOf("Cereza");
//Ahora llamamos la Variable "posicion" para conocer el puesto de nuestro elemento.
posicion
2
//Ahora sabemos que "Cereza" está en la posición [2] del Array frutas.

Creo que no es necesario poner “Uvas” en frutas.pop(“Uvas”)

Ya que siempre elimina el último elemento aunque pongas el nombre de otra fruta, o lo dejes vacio o incluso pongas cualquier texto. Siempre eliminará las Uvas

De pronto en los aportes ya hay enlaces de documentación pero les comparto uno interesante.
(https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array)

También podemos hacer funciones para ello

var masFrutas = function agregarFruta(af) {
	return frutas.push(af);
}

la función .pop() elimina el último elemento del array y la función .shift() elimina el primero , no es necesario pasarles un parámetro y tampoco es necesario hacer el llamado de esas funciones asignándolo a una variable para lograr modificar el array:

var frutas = ["Manzana", "Plátano", "Cereza", "Fresas"];

frutas.push("Uvas"); //  Si se asigna a una variable devuelve la longitud del array
frutas.pop(); //  Si se asigna a una variable devuelve el elemento eliminado del array
frutas.unshift("Uvas"); //  Si se asigna a una variable devuelve la longitud del array
frutas.shift(); //  Si se asigna a una variable devuelve el elemento eliminado del array

Los métodos pop y shift no solo eliminan elementos de un arreglo, sino que también retornan
el elemento que eliminan.
Esto puede ser útil, en caso de que necesites hacer algo mas en tu código.
Un pequeño ejemplo.

var  numeros  = [2, 6, 8, 10];

var ultimoNumero  = numeros.pop();     

var multiplica = ultimoNumero * 2;  

console.log(multiplica);  //  imprime 20.


El objeto Array de JavaScript es un objeto global que es usado en la construcción de arrays, que son objetos tipo lista de alto nivel.

La propiedad length de un objeto que es una instancia de tipo Array establece o devuelve la cantidad de elementos en esa matriz. El valor es un entero sin signo de 32 bits que siempre es numéricamente mayor que el índice más alto en la matriz.

El método push() añade uno o más elementos al final de un array y devuelve la nueva longitud del array.

El método pop() elimina el último elemento de un array y lo devuelve. Este método cambia la longitud del array.

El método unshift() agrega uno o más elementos al inicio del array, y devuelve la nueva longitud del array.

El método shift() elimina el primer elemento del array y lo retorna. Este método modifica la longitud del array.

El método indexOf() retorna el primer índice en el que se puede encontrar un elemento dado en el array, ó retorna -1 si el elemento no esta presente.

Fuente: MDN Web Docs

En programación cuando se habla de “Mutación” nos referimos a que pueden ser alterados, es decir, que cambia su valor. En cambio “Inmutable” hace referencia a que NO puede ser alterado.

var frutas = ["Pera", "Platano", "Mandarina", "Manzana", "fresa"];
console.log(frutas);

// longitud de un array
console.log(frutas.length);

// acceder a un elemento especifico
console.log(frutas[2]);

// agregar elementos arrays
frutas.push("Coco");
console.log(frutas);

// eliminar elementos de array
frutas.pop();
console.log(frutas);

// Agregar nuevo valor pero al inicio
frutas.unshift("Cereza");
console.log(frutas);

// eliminar el primer elemento del array
frutas.shift();
console.log(frutas);

// saber que esta en la posicion de un array
pos=frutas.indexOf("Pera");
console.log(pos);

Ojo que .pop no elimina cualquiera elemento del array , siempre el ultimo

Un aporte de otro compañero, lo replico por que pensé que con .pop podía eliminar cualquier elemento y esa era una duda que tenia.

En el metodo .pop() el argumento que se le da a la funcion no cambia el resultado, de hecho se puede omitir, si escriben array.pop() ya eso basta para sacar el ultimo elemento del array, no es necesario saber su nombre

¿Qué sucedería si tuviéramos por ejemplo el valor “Cereza” repetido en varias partes del array y aplicáramos el siguiente código?

frutas.indexOf("Cereza"); 

Solo devolvería el índice más cercano a inicio del array. Las demás posiciones de “Cereza” no las tendría en cuenta.

Es obligatorio mandar el texto entre los paréntesis?
Hice la prueba sin los textos y los métodos funcionan de igual manera.

mis apuntes de esta clase:
si algo me faltó díganme!

los arrays son data types que permiten guardar sequencias de información.

var estudiantes = [Jorge, Carlos, Andrés];

las posiciones de los arrays empiezan desde 0 como generalmente se cuenta en programación.

estudiantes [0] --> Jorge
estudiantes [1] --> Carlos
estudiantes [2] --> Andrés

los Arrays tienen propiedades que podemos acceder mediante la siguiente notación.

estudiantes.length

algunas de estas propiedades ejecutan funciones, a estas se les llama métodos.

push(): agrega un elemento al final del Array.
pop(): elimina un elemento al final del Array.
unshift (); agrega un elemento al inicio.
shift () elimina el primer elemento del Array.

estudiantes.push(“Roberto”);
estudiantes = [Jorge, Carlos, Andrés, Roberto];

Nota: no es necesario poner el nombre del elemento que quiero borrar, con .pop siempre se borra el ultimo y con .shift siempre el primero es eliminado, lo comento porque Diego lo menciona muy por encima

Con el método .splice(pos, cantidad de elementos) se puede eliminar el elemento de la posición buscada con el método indexOf, si solo quieres eliminar ese elemento lo acompañas con un 1 si requieres eliminar más elementos le agregas la cantidad.

Si no se conoce un elemento de la lista y se desea eliminar, por ejemplo el primer elemento, se puede utilizar solo la instrucción nombreArray.shift();

Bien explicada la clase.