Array.prototype.copyWithin()

La méthode copyWithin() effectue une copie superficielle (shallow copy) d'une partie d'un tableau sur ce même tableau et le renvoie, sans modifier sa taille.

["alpha", "bravo", "charlie", "delta"].copyWithin(2, 0);

// Le résultat est ["alpha", "bravo", "alpha", "bravo"]

Syntaxe

arr.copyWithin(cible)
arr.copyWithin(cible, début)
arr.copyWithin(cible, début, fin)

Paramètres

cible

Indice à partir duquel la séquence sera copiée. Si la valeur est négative, cible sera compté à partir de la fin du tableau.

Si cible est supérieur ou égal à arr.length, rien ne sera copié. Si cible est positionné apès début, la séquence copiée sera réduite pour correspondre à arr.length.

début Facultatif
Indice de début de la séquence a copier. Si la valeur est négative, début sera compté à partir de la fin du tableau.
Si début est omis, copyWithin copiera à partir du début du tableau (par défaut 0).
fin Facultatif
Indice de fin de la séquence a copier. copyWithin copie jusqu'à fin (non-inclusif). Si la valeur est négative, end sera compté à partir de la fin du tableau.
Si end est omis, copyWithin copiera jusqu'à la fin du tableau (par défaut arr.length).

Valeur de retour

Le tableau modifié par la méthode.

Description

La fonction copyWithin() fonctionne de la même façon que memmove en C/C++. C'est une méthode très performante pour décaler les données d'un Array ou d'un TypedArray (dans ce cas, on pourra utiliser TypedArray.copyWithin()). La séquence est copiée et collée en une opération. La séquence collée aura les valeurs copiées même si les zones de copiage et de collage se chevauchent.

La fonction copyWithin() est intentionnellement générique, il n'est pas nécessaire que this soit un objet Array.

De plus, copyWithin() est une méthode qui modifie l'objet courant. Elle ne modifie pas la longueur de this, mais change son contenu et créé de nouvelles propriétés si nécessaire.

Exemples

[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({length: 5, 3: 1}, 0, 3);
// {0: 1, 3: 1, length: 5}

// Les tableaux typés ES6 sont des sous-classes d'Array
var i32a = new Int32Array([1, 2, 3, 4, 5]);

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

// Sur les plates-formes qui ne supportent pas encore ES6 :
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]

Prothèse d'émulation (polyfill)

Cette méthode a été ajoutée à la spécification ECMAScript 6 et peut ne pas être utilisable dans tous les environnements. Voici un fragment de code qui permet d'émuler cette méthode :

if (!Array.prototype.copyWithin) {
  Array.prototype.copyWithin = function(target, start/*, end*/) {
    // Étapes 1 à 2.
    if (this == null) {
      throw new TypeError('this vaut null ou n est pas défini');
    }

    var O = Object(this);

    // Étapes 3 à 5.
    var len = O.length >>> 0;

    // Étapes 6 à 8.
    var relativeTarget = target >> 0;

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

    // Étapes 9 à 11.
    var relativeStart = start >> 0;

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

    // Étapes 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);

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

    // Étapes 16 à 17.
    var direction = 1;

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

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

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

    // Étape 19.
    return O;
  };
}

Spécifications

Spécification État Commentaires
ECMAScript 2015 (6th Edition, ECMA-262)
La définition de 'Array.prototype.copyWithin' dans cette spécification.
Standard Définition intiale.
ECMAScript 2016 (ECMA-262)
La définition de 'Array.prototype.copyWithin' dans cette spécification.
Standard  
ECMAScript 2017 Draft (ECMA-262)
La définition de 'Array.prototype.copyWithin' dans cette spécification.
Projet  

Compatibilité des navigateurs

Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Edge Opera Safari
Support simple 45 32 (32) Pas de support 12 Pas de support 9.0
Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Support simple Pas de support Pas de support 32.0 (32) Pas de support Pas de support Pas de support

Voir aussi

Étiquettes et contributeurs liés au document

 Contributeurs à cette page : SphinxKnight, VincentCharpentier, goofy_bz, ferncoder
 Dernière mise à jour par : SphinxKnight,