perl | arreglos

En Perl, array es un tipo especial de variable. La array se utiliza para almacenar la lista de valores y cada objeto de la lista se denomina elemento. Los elementos pueden ser un número, una string o cualquier tipo de datos escalares , incluida otra variable.

 
Ejemplo:

@number = (50, 70, 46);             
@names = ("Geeks", "For", "Geeks");

Creación de array: en la programación Perl, cada variable de array se declara utilizando el signo «@» antes del nombre de la variable. Una sola array también puede almacenar elementos de múltiples tipos de datos. Por ejemplo:

# Define an array
@arr = (1, 2, 3);
@arr = (1, 2, 3, "Hello");

Creación de arrays usando la función qw: la función
qw() es la forma más fácil de crear una array de palabras entre comillas simples. Toma una expresión como entrada y extrae las palabras separadas por un espacio en blanco y luego devuelve una lista de esas palabras. Lo mejor es que la expresión puede estar rodeada por cualquier delimitador como-() ” [] {} // etc. Sin embargo,() y // se usan generalmente.

Sintaxis:

qw (Expression)
qw /Expression/
qw 'Expression'
qw {Expression}

Ejemplo :

# Perl program to demonstrate qw function
  
# using qw function
@arr1 = qw /This is a Perl Tutorial by GeeksforGeeks/;
  
# Creates array2 with elements at
# index 2,3,4 in array1
@arr2 = @arr1[2,3,4]; 
  
print "Elements of arr1 are:\n";
foreach $ele (@arr1)
{
    print "$ele \n";
}
  
print "Elements of arr2 are:\n";
foreach $ele (@arr2)
{
     print "$ele \n";
}

Producción:

Elements of arr1 are:
This 
is 
a 
Perl 
Tutorial 
by 
GeeksforGeeks 
Elements of arr2 are:
a 
Perl 
Tutorial 

Acceso a los elementos de la array: para acceder a los elementos de una array, debemos anteponer el signo «$» al nombre de la variable de la array seguido del índice entre corchetes. Por ejemplo:

# Define an array
@arr = (1, 2, 3);

# Accessing and printing first 
# element of an array
print "$arr[0]\n";

# Accessing and printing second
# element of an array
print "$arr[1]\n";

Ejemplo:

# Perl program to demonstrate Array's
# creation and accessing the array's elements
  
# Creation an array fruits
@fruits = ("apple", "banana", "pineapple", "kiwi");
  
# printing the array
print "@fruits\n";
  
# Prints the array's elements
# one by one using index
print "$fruits[0]\n";
print "$fruits[1]\n";
print "$fruits[2]\n";
print "$fruits[3]\n";

Producción:

apple banana pineapple kiwi
apple
banana
pineapple
kiwi

Nota: los índices de array siempre comienzan desde cero. Para acceder al primer elemento debe dar 0 como índices. También podemos dar un índice negativo . Pero dar un índice negativo dará como resultado seleccionar los elementos de la array desde el final, no desde el principio.

Ejemplo:

# Perl program to demonstrate 
# negative index of array
  
# Creation an array fruits
@fruits = ("apple", "banana", "pineapple", "kiwi");
  
# Prints the array's elements
# one by one using negative index
print "$fruits[-1]\n";
print "$fruits[-2]\n";

Producción:

kiwi
pineapple

Arrays numéricas secuenciales: Perl también proporciona un atajo para crear una array secuencial de números o letras. Facilita la tarea del usuario. Usando arrays de números secuenciales, los usuarios pueden omitir bucles y escribir cada elemento al contar hasta 1000 o letras de la A a la Z, etc.

Ejemplo:

@array = (1..9); # array with numbers from 1 to 9
@array = (a..h); # array with letters from a to h

Programa:

# Perl program to demonstrate
# Sequential Number Arrays
  
# Sequential Number Arrays for 
# numbers and letters
@nums = (1..9);
@letters = (a..h);
  
# Prints array- nums
print "@nums\n"; 
  
# Prints array- letters
print "@letters\n";  

Producción:

1 2 3 4 5 6 7 8 9
a b c d e f g h

Tamaño de una array: el tamaño de una array (tamaño físico de la array) se puede encontrar evaluando la array en un contexto escalar. El valor devuelto será el número de elementos en la array. Una array se puede evaluar en un contexto escalar de dos maneras:

1. Contexto escalar implícito

   $size = @array;

2. Contexto escalar explícito usando palabra clave escalar

   $size = scalar @array;

Ambas formas producirán el mismo resultado, por lo que se prefiere usar un contexto escalar implícito.

Ejemplo:

# Perl program to demonstrate 
# the length of an array
  
# declaring an array
@arr = (11, 22, 33, 44, 55, 66);
  
# Storing the length of array 
# in variable imp_size
# implicit scalar context
$imp_size = @arr;
  
# Storing the length of array
# in variable exp_size
# explicit scalar context
$exp_size = scalar @arr;
  
print "Size of arr(imp_size) $imp_size\n";
print "Size of arr(exp_size) $exp_size";

Producción:

Size of arr(imp_size) 6
Size of arr(exp_size) 6

Nota: En las arrays de Perl, el tamaño de una array siempre es igual a (índice_máximo + 1), es decir

size = maximum_index + 1

Y puede encontrar el índice máximo de array usando $#array . Entonces @array y scalar @array siempre se usan para encontrar el tamaño de una array.

Ejemplo:

# Perl program to find size and 
# maximum index of an array
  
#!/usr/bin/perl
  
# Array declaration and 
# assigning values to it
@arr = (10, 17, 19, 20, 25);
  
# to find size of array
$size_of_array = @arr;
  
# to find Maximum index of array
$maximum_index = $#arr;
  
# displaying result
print "Maximum Index of the Array: $maximum_index\n";
print "The Size of the Array:  $size_of_array\n";

Producción:

Maximum Index of the Array: 4
The Size of the Array:  5

Iterando a través de una array: podemos iterar en una array de dos maneras:

• Iterando a través del rango: podemos iterar a través del rango encontrando el tamaño de una array y luego ejecutando un ciclo for desde 0 hasta el tamaño – 1 y luego accediendo a los elementos de la array.

  Ejemplo:

  # Perl program to illustrate  # iteration through range    # array creation @arr = (11, 22, 33, 44, 55);    # size of array $len = @arr;    for ($b = 0; $b < $len; $b = $b + 1) {     print "\@arr[$b] = $arr[$b]\n"; }

  Producción:

  @arr[0] = 11
  @arr[1] = 22
  @arr[2] = 33
  @arr[3] = 44
  @arr[4] = 55
  

• Iterando a través de elementos (bucle foreach): podemos iterar a través de los elementos usando el bucle foreach. Usando esto, podemos acceder directamente a los elementos de la array usando un bucle en lugar de ejecutar un bucle sobre su rango y luego acceder a los elementos.

  Ejemplo:

  # Perl program to illustrate Iterating  # through elements(foreach Loop)    # creating array @l = (11, 22, 33, 44, 55);    # foreach loop foreach $a (@l) {       print "$a "; }

  Producción:

  11 22 33 44 55