Array.prototype.copyWithin()

Metoda copyWithin() tworzy kopie płytkie części tablicy w innej części tej samej tablicy i zwraca tę tablicę bez modyfikowania jej długości.

arr.copyWithin(cel[, start[, koniec]])

cel

Indeks (liczony od zera), do którego ma zostać skopiowana sekwencja. Jeśli wartość target będzie ujemna, pozycja będzie liczona od końca tablicy.

Jeśli cel jest większy lub równy arr.length, nic nie zostanie skopiowane. Jeśli wartość cel będzie większa niż start, kopiowana sekwencja zostanie przycięta tak, aby pasować do arr.length.

start Optional

Indeks (liczony od zera), określający pozycję początkową sekwencji, która ma zostać skopiowana. Jeśli wartość ta będzie ujemna, start będzie liczony od końca tablicy.

Jeśli wartość start nie jest podana, copyWithin skopiuje sekwencję zaczynając od indeksu 0. 

koniec Optional

Indeks (liczony od zera), określający pozycję końcową sekwencji, która ma zostać skopiowana, z wyłączeniem wartości pod indeksem koniec. Jeśli wartość ta będzie ujemna, koniec będzie liczony od końca tablicy.

Jeśli wartość koniec nie jest podana, copyWithin skopiuje sekwencję do ostatniego indeksu (domyślnie do arr.length).

Zmodyfikowana tablica.

Metoda copyWithin działa jak memmove w C/C++ i jest wysokowydajną metodą przesuwania wartości w obiektach Array. Dotyczy to szczególnie metody o tej samej nazwie TypedArray. Sekwencja jest kopiowana i wklejana w jednej operacji, a wklejona sekwencja będzie zawierać skopiowane wartości nawet wtedy, gdy zakres żródłowy (kopiowania) i docelowy (wklejania) nakładają się na siebie.

Funkcja copyWithin jest celowo ogólna, nie wymaga, by jej wartość this była obiektem typu Array.

Metoda copyWithin jest modyfikowalna. Nie zmienia długości this, ale zmienia zawartość this i tworzy nowe własności, jeśli jest to konieczne.

if (!Array.prototype.copyWithin) {
  Object.defineProperty(Array.prototype, 'copyWithin', {
    value: function(target, start/*, end*/) {
    // Kroki 1-2.
    if (this == null) {
      throw new TypeError('this is null or not defined');
    }

    var O = Object(this);

    // Kroki 3-5.
    var len = O.length >>> 0;

    // Kroki 6-8.
    var relativeTarget = target >> 0;

    var to = relativeTarget < 0 ?
      Math.max(len + relativeTarget, 0) :
      Math.min(relativeTarget, len);

    // Kroki 9-11.
    var relativeStart = start >> 0;

    var from = relativeStart < 0 ?
      Math.max(len + relativeStart, 0) :
      Math.min(relativeStart, len);

    // Kroki 12-14.
    var end = arguments[2];
    var relativeEnd = end === undefined ? len : end >> 0;

    var final = relativeEnd < 0 ?
      Math.max(len + relativeEnd, 0) :
      Math.min(relativeEnd, len);

    // Krok 15.
    var count = Math.min(final - from, len - to);

    // Kroki 16-17.
    var direction = 1;

    if (from < to && to < (from + count)) {
      direction = -1;
      from += count - 1;
      to += count - 1;
    }

    // Krok 18.
    while (count > 0) {
      if (from in O) {
        O[to] = O[from];
      } else {
        delete O[to];
      }

      from += direction;
      to += direction;
      count--;
    }

    // Krok 19.
    return O;
  },
  configurable: true,
  writable: true
  });
}

[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]

[].copyWithin.call({długość: 5, 3: 1}, 0, 3)
// {0: 1, 3: 1, długość: 5}

// ES2015 Typowane tablice są podklasami zwykłej tablicy (Array)
var i32a = new Int32Array([1, 2, 3, 4, 5])

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

// Na platformach niewspierających jeszcze ES 2015:
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]

• Array