Array.prototype.copyWithin()

Prubalo

const array1 = ["a", "b", "c", "d", "e"];

// Copy to index 0 the element at index 3
console.log(array1.copyWithin(0, 3, 4));
// Expected output: Array ["d", "b", "c", "d", "e"]

// Copy to index 1 all elements from index 3 to the end
console.log(array1.copyWithin(1, 3));
// Expected output: Array ["d", "d", "e", "d", "e"]

Sintaxis

arr.copyWithin(target)
arr.copyWithin(target, start)
arr.copyWithin(target, start, end)

Parmetros

target

ndice basado en cero que establece en dnde dentro de la secuencia original se insertar la secuencia copiada. Si es negativo, target se contar desde el final. -1 es el ltimo elemento, -2 el penltimo, etc.

Si target es igual o mayor que arr.length, no se copiar nada. Si target es posicionado despus de start, la secuencia copiada se recortar para que encaje con arr.length.

start Opcional

ndice basado en cero a partir del cual comenzar la copia de elementos. Si es negativo, start comenzar a contarse desde el final.

Si start es omitido, copyWithin copiar desde el principio (por defecto es 0).

end Opcional

ndice basado en cero hasta el cual se copiarn los elementos. copyWithin copiar hasta pero sin incluir el end. Si es negativo, end ser contado desde el final.

Si end es omitido, copyWithin copiar hasta el final ( por defecto es arr.length).

Valor de retorno

El array modificado.

Descripcin

copyWithin es similar a la funcin memmove de C y C++ , siendo altamente eficiente para desplazar los datos en un Array o TypedArray. La secuencia de datos es leda y escrita en una sola operacin; la escritura ser correcta incluso en el caso de que la zona de lectura y el destino de escritura se solapen.

La funcin copyWithin es intencionadamente genrica, permitiendo que se aplique en contextos en los cuales this no sea necesariamente un objeto Array.

El mtodo copyWithin es un mtodo mutador. No altera la propiedad length de this, pero cambiar su contenido y crear nuevas propiedades si es necesario.

Ejemplos

En los siguientes ejemplos cntrate en los siguientes aspectos:

• El tamao del contexto en el que se aplica no cambia. En los ejemplos el array parte con cinco elementos y siempre mantiene cinco elementos.
• start y end trabajan juntos para decidir qu se copiar. Siempre tienen valor por defecto aunque omitas end, o start y end.
• target trabaja solo y debe especificarse. Indica el lugar para en el que la copia comenzar a sobreescribir datos existentes. Debe estar dentro de los lmites en el contexto que se aplique.
• escribir arr.copyWithin( n ) es lo mismo que arr.copyWithin( n, 0, arr.length)

[1, 2, 3, 4, 5].copyWithin(-2);
// [1, 2, 3, 1, 2]

[1, 2, 3, 4, 5].copyWithin(0, 3);
// [4, 5, 3, 4, 5]

[1, 2, 3, 4, 5].copyWithin(0, 3, 4);
// [4, 2, 3, 4, 5]

[1, 2, 3, 4, 5].copyWithin(-2, -3, -1);
// [1, 2, 3, 3, 4]

A continuacin se aplica en el contexto de un objeto array-like:

• El objeto contextual tiene alguna propiedad con clave numrica, y una propiedad length. Esto es suficiente para considerarse array-like.
• observa que no se modifica la propiedad length, a pesar de que se ha introducido una nueva propiedad con clave 0. A esto ser refiere cuando se dice que copyWithin es un mtodo mutador. Por qu se cre esta nueva propiedad? porque mediante el argumento target se especific que la copia deba comenzar a partir de un ndice que no exista!!

[].copyWithin.call({ length: 5, 3: 1 }, 0, 3);
// {0: 1, 3: 1, length: 5}

Lo que sigue ahora son las subclases tipadas de Array en ES6:

// Arrays tipados en ES6. Son subclases de Array
var i32a = new Int32Array([1, 2, 3, 4, 5]);

i32a.copyWithin(0, 2);
// Int32Array [3, 4, 5, 4, 5]

// En plataformas que todava no siguen la norma ES6:
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]

Polyfill

if (!Array.prototype.copyWithin) {
  Array.prototype.copyWithin =
    // Array: Number[, Number[, Number]]
    function copyWithin(target, start, stop) {
      var positiveT = target >= 0,
        positiveS = (start = start | 0) >= 0,
        length = this.length,
        zero = 0,
        r = function () {
          return (+new Date() * Math.random()).toString(36);
        },
        delimiter = "\b" + r() + "-" + r() + "-" + r() + "\b",
        hold;

      stop = stop || this.length;
      hold = this.slice
        .apply(
          this,
          positiveT ? [start, stop] : positiveS ? [start, -target] : [start],
        )
        .join(delimiter);

      return (
        this.splice.apply(
          this,
          positiveT
            ? [target, stop - start, hold]
            : positiveS
              ? [target, stop, hold]
              : [target, start, hold],
        ),
        this.join(delimiter).split(delimiter).slice(zero, length)
      );
    };
}

Especificaciones

Compatibilidad con navegadores

Ver tambin

• Array