Vector

vector<T>es el único tipo de colección primitivo proporcionado por Move. A vector<T>es una colección homogénea de T's que puede crecer o reducirse empujando o sacando valores del "final".

Se puede crear una instancia de A vector<T>con cualquier tipo T. Por ejemplo, vector<u64>, vector<address>, vector<0x42::MyModule::MyResource>y vector<vector<u8>>son todos tipos de vectores válidos.

Literales

vectorLiterales generales

Se pueden crear vectores de cualquier tipo con vectorliterales.

Sintaxis	Tipo	Descripción
vector[]	vector[]: vector<T>¿Dónde Testá cualquier tipo único que no sea de referencia?	Un vector vacío
vector[e1, ..., en]	vector[e1, ..., en]: vector<T>donde e_i: Tst 0 < i <= nyn > 0	Un vector con nelementos (de longitud n)

En estos casos, el tipo de vectorse infiere, ya sea a partir del tipo de elemento o del uso del vector. Si no se puede inferir el tipo, o simplemente para mayor claridad, el tipo se puede especificar explícitamente:

Copiar

vector<T>[]: vector<T>
vector<T>[e1, ..., en]: vector<T>

Ejemplo de literales vectoriales

Copiar

(vector[]: vector<bool>);
(vector[0u8, 1u8, 2u8]: vector<u8>);
(vector<u128>[]: vector<u128>);
(vector<address>[@0x42, @0x100]: vector<address>);

vector<u8>literales

Un caso de uso común para los vectores en Move es representar "matrices de bytes", que se representan con vector<u8>. Estos valores se utilizan a menudo con fines criptográficos, como una clave pública o un resultado hash. Estos valores son tan comunes que se proporciona una sintaxis específica para que los valores sean más legibles, en lugar de tener que usar vector[]donde cada valor individual u8se especifica en forma numérica.

Actualmente hay dos tipos de vector<u8>literales admitidos: cadenas de bytes y cadenas hexadecimales .

Cadenas de bytes

Las cadenas de bytes son cadenas literales entre comillas con el prefijo a b, por ejemplo b"Hello!\n".

Son cadenas codificadas en ASCII que permiten secuencias de escape. Actualmente, las secuencias de escape admitidas son:

Secuencia de escape	Descripción
	Nueva línea (o avance de línea)
	Retorno de carro
	Pestaña
\\	Barra invertida
\0	Nulo
\"	Cita
\xHH	Escape hexadecimal, inserta la secuencia de bytes hexadecimalesHH

Cuerdas hexagonales

Las cadenas hexadecimales son cadenas literales entre comillas con el prefijo a x, por ejemplo x"48656C6C6F210A".

Cada par de bytes, desde 00hasta FF, se interpreta como u8un valor codificado en hexadecimal. Así, cada par de bytes corresponde a una única entrada en el archivo vector<u8>.

Literales de cadena de ejemplo

Copiar

script {
fun byte_and_hex_strings() {
    assert!(b"" == x"", 0);
    assert!(b"Hello!\n" == x"48656C6C6F210A", 1);
    assert!(b"\x48\x65\x6C\x6C\x6F\x21\x0A" == x"48656C6C6F210A", 2);
    assert!(
        b"\"Hello\tworld!\"\n \r \\Null=\0" ==
            x"2248656C6C6F09776F726C6421220A200D205C4E756C6C3D00",
        3
    );
}
}

Operaciones

vectorproporciona varias operaciones a través del std::vectormódulo en la biblioteca estándar Move, como se muestra a continuación. Es posible que se agreguen más operaciones con el tiempo. El documento actualizado vectorse puede encontrar aquí .

Función	Descripción	¿Aborta?
vector::empty<T>(): vector<T>	Crea un vector vacío que pueda almacenar valores de tipo.T	Nunca
vector::is_empty<T>(): bool	Retorna truesi el vector vno tiene elementos y falseen caso contrario.	Nunca
vector::singleton<T>(t: T): vector<T>	Crea un vector de tamaño 1 que contengat	Nunca
vector::length<T>(v: &vector<T>): u64	Devuelve la longitud del vector.v	Nunca
vector::push_back<T>(v: &mut vector<T>, t: T)	Añadir tal final dev	Nunca
vector::pop_back<T>(v: &mut vector<T>): T	Eliminar y devolver el último elemento env	si vesta vacio
vector::borrow<T>(v: &vector<T>, i: u64): &T	Devuelve una referencia inmutable al Tíndice ati	Si ino está dentro de los límites
vector::borrow_mut<T>(v: &mut vector<T>, i: u64): &mut T	Devolver una referencia mutable al Tíndice ati	Si ino está dentro de los límites
vector::destroy_empty<T>(v: vector<T>)	Borrarv	Si vno esta vacio
vector::append<T>(v1: &mut vector<T>, v2: vector<T>)	Agregue los elementos v2al final dev1	Nunca
vector::reverse_append<T>(lhs: &mut vector<T>, other: vector<T>)	Empuja todos los elementos del othervector dentro del lhsvector, en el orden inverso al que ocurrieron enother	Nunca
vector::contains<T>(v: &vector<T>, e: &T): bool	Devuelve verdadero si eestá en el vector v. De lo contrario, devuelve falso	Nunca
vector::swap<T>(v: &mut vector<T>, i: u64, j: u64)	Intercambia los elementos en los índices iésimo y jésimo del vector.v	Si io jestá fuera de límites
vector::reverse<T>(v: &mut vector<T>)	Invierte el orden de los elementos en el vector ven su lugar.	Nunca
vector::reverse_slice<T>(v: &mut vector<T>, l: u64, r: u64)	Invierte el orden de los elementos [l, r) en el vector ven su lugar	Nunca
vector::index_of<T>(v: &vector<T>, e: &T): (bool, u64)	Devuelve (true, i)si eestá en el vector ven el índice i. De lo contrario, regresa(false, 0)	Nunca
vector::insert<T>(v: &mut vector<T>, i: u64, e: T)	Inserte un nuevo elemento een la posición 0 <= i <= longitud, usando O(longitud - i) tiempo	Si iestá fuera de límites
vector::remove<T>(v: &mut vector<T>, i: u64): T	Elimina el ienésimo elemento del vector v, desplazando todos los elementos posteriores. Esto es O(n) y preserva el orden de los elementos en el vector.	Si iestá fuera de límites
vector::swap_remove<T>(v: &mut vector<T>, i: u64): T	Intercambie el iésimo elemento del vector vcon el último elemento y luego extraiga el elemento. Este es O(1), pero no conserva el orden de los elementos en el vector.	Si iestá fuera de límites
vector::trim<T>(v: &mut vector<T>, new_len: u64): u64	Recorta el vector val tamaño más pequeño new_leny devuelve los elementos desalojados en orden	new_lenes mayor que la longitud dev
vector::trim_reverse<T>(v: &mut vector<T>, new_len: u64): u64	Recorta el vector val tamaño más pequeño new_leny devuelve los elementos desalojados en orden inverso.	new_lenes mayor que la longitud dev
vector::rotate<T>(v: &mut vector<T>, rot: u64): u64	rotar (&mut [1, 2, 3, 4, 5], 2) -> [3, 4, 5, 1, 2] en su lugar, devuelve el punto de división, es decir. 3 en este ejemplo	Nunca
vector::rotate_slice<T>(v: &mut vector<T>, left: u64, rot: u64, right: u64): u64	rotar un sector [izquierda, derecha) con izquierda <= rot <= derecha en su lugar, devuelve el punto de división	Nunca

Ejemplo

Copiar

use std::vector;

let v = vector::empty<u64>();
vector::push_back(&mut v, 5);
vector::push_back(&mut v, 6);

assert!(*vector::borrow(&v, 0) == 5, 42);
assert!(*vector::borrow(&v, 1) == 6, 42);
assert!(vector::pop_back(&mut v) == 6, 42);
assert!(vector::pop_back(&mut v) == 5, 42);

Destruir y copiar vectors

Algunos comportamientos vector<T>dependen de las habilidades del tipo de elemento T. Por ejemplo, los vectores que contienen elementos que no tienen dropno se pueden descartar implícitamente como ven el ejemplo anterior; deben destruirse explícitamente con vector::destroy_empty.

Tenga en cuenta que vector::destroy_emptyabortará en tiempo de ejecución a menos que veccontenga cero elementos:

Copiar

fun destroy_any_vector<T>(vec: vector<T>) {
    vector::destroy_empty(vec) // deleting this line will cause a compiler error
}

Pero no se produciría ningún error al eliminar un vector que contiene elementos con drop:

Copiar

fun destroy_droppable_vector<T: drop>(vec: vector<T>) {
    // valid!
    // nothing needs to be done explicitly to destroy the vector
}

De manera similar, los vectores no se pueden copiar a menos que el tipo de elemento sea copy. En otras palabras, a vector<T>tiene copysi y sólo si Ttiene copy. Sin embargo, incluso los vectores copiables nunca se copian implícitamente:

Copiar

let x = vector::singleton<u64>(10);
let y = copy x; // compiler error without the copy!

Las copias de vectores grandes pueden ser costosas, por lo que el compilador requiere explícitos copypara que sea más fácil ver dónde están sucediendo.

Para obtener más detalles, consulte las secciones sobre habilidades de tipo y genéricos.

Propiedad

Como se mencionó anteriormente, vectorlos valores se pueden copiar solo si los elementos se pueden copiar. En ese caso, la copia debe ser explícita mediante un copyo una desreferencia *.