1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
---
title: Array.prototype.copyWithin()
slug: Web/JavaScript/Referencia/Objetos_globales/Array/copyWithin
tags:
- Array
- ECMAScript 2015
- JavaScript
- Prototipo
- Referencia
- metodo
- polyfill
translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
---
<div>{{JSRef}}</div>
<p>El método <code><strong>copyWithin()</strong></code> transfiere una copia plana de una sección a otra dentro del mismo array ( o contexto similar ), sin modificar su propiedad length y lo devuelve.</p>
<p>{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}</p>
<h2 id="Sintaxis">Sintaxis</h2>
<pre class="syntaxbox"><var>arr.copyWithin(target)
arr.copyWithin(target, start)
arr.copyWithin(target, start, end)</var></pre>
<h3 id="Parámetros">Parámetros</h3>
<dl>
<dt><code>target</code></dt>
<dd>Índice basado en cero que establece en dónde dentro de la secuencia original se insertará la secuencia copiada. Si es negativo, <code>target</code> se contará desde el final. -1 es el último elemento, -2 el penúltimo, etc.</dd>
<dd>Si <code>target</code> es igual o mayor que <code>arr.length</code>, no se copiará nada. Si <code>target</code> es posicionado después de <code>start</code>, la secuencia copiada se recortará para que encaje con <code>arr.length</code>.</dd>
<dt><code>start</code> {{optional_inline}}</dt>
<dd>Índice basado en cero a partir del cual comenzar la copia de elementos. Si es negativo, start comenzará a contarse desde el final.</dd>
<dd>Si <code>start</code> es omitido, <code>copyWithin</code> copiará desde el principio (por defecto es 0).</dd>
<dt><code>end</code> {{optional_inline}}</dt>
<dd>Índice basado en cero hasta el cual se copiarán los elementos. <code>copyWithin</code> copiará hasta pero sin incluir el end. Si es negativo, <code>end</code> será contado desde el final.</dd>
<dd>Si <code>end</code> es omitido, <code>copyWithin</code> copiará hasta el final ( por defecto es <code>arr.length </code>).</dd>
</dl>
<h3 id="Valor_de_retorno">Valor de retorno</h3>
<p>El array modificado.</p>
<h2 id="Descripción">Descripción</h2>
<p><code>copyWithin</code> es similar a la función <code>memmove</code> de C y C++ , siendo altamente eficiente para desplazar los datos en un {{jsxref("Array")}} o {{jsxref("TypedArray")}}. La secuencia de datos es leída y escrita en una sola operación; la escritura será correcta incluso en el caso de que la zona de lectura y el destino de escritura se solapen.</p>
<p>La función <code>copyWithin</code> es intencionadamente <em>genérica</em>, permitiendo que se aplique en contextos en los cuales <code>this</code> no sea necesariamente un objeto {{jsxref("Array")}}.</p>
<p>El método <code>copyWithin</code> es un método mutador. No altera la propiedad <code>length</code> de <code>this</code>, pero cambiará su contenido y creará nuevas propiedades si es necesario.</p>
<h2 id="Ejemplos">Ejemplos</h2>
<p>En los siguientes ejemplos céntrate en los siguientes aspectos:</p>
<ul>
<li>El tamaño del contexto en el que se aplica no cambia. En los ejemplos el array parte con cinco elementos y siempre mantiene cinco elementos.</li>
<li><code>start</code> y <code>end</code> trabajan juntos para decidir qué se copiará. Siempre tienen valor por defecto aunque omitas <code>end</code>, o <code>start</code> y <code>end</code>.</li>
<li><code>target</code> trabaja solo y debe especificarse. Indica el lugar para en el que la copia comenzará a sobreescribir datos existentes. Debe estar dentro de los límites en el contexto que se aplique.</li>
<li>escribir <code>arr.copyWithin( n ) </code>es lo mismo que <code>arr.copyWithin( n, 0, arr.length)</code></li>
</ul>
<pre class="brush: js">[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]
</pre>
<p>A continuación se aplica en el contexto de un objeto <strong>array-like</strong>:</p>
<ul>
<li>El objeto contextual tiene alguna propiedad con clave numérica, y una propiedad length. Esto es suficiente para considerarse array-like.</li>
<li>observa que <strong>no</strong> 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 <code>copyWithin</code> es un método <strong>mutador</strong>. ¿Por qué se creó esta nueva propiedad? porque mediante el argumento target se especificó que la copia debía comenzar a partir de un índice que ¡¡no existía!!</li>
</ul>
<pre class="brush: js">[].copyWithin.call({length: 5, 3: 1}, 0, 3);
// {0: 1, 3: 1, length: 5}
</pre>
<p>Lo que sigue ahora son las subclases tipadas de Array en ES6:</p>
<pre class="brush: js">// 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 todavía no siguen la norma ES6:
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]</pre>
<h2 id="Polyfill">Polyfill</h2>
<pre class="brush: js">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);
}
}</pre>
<h2 id="Especificaciones">Especificaciones</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Especificación</th>
<th scope="col">Estado</th>
<th scope="col">Comentario</th>
</tr>
<tr>
<td>{{SpecName('ES6', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}</td>
<td>{{Spec2('ES6')}}</td>
<td>Definición inicial.</td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td> </td>
</tr>
</tbody>
</table>
<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2>
<div>
<p>{{Compat("javascript.builtins.Array.copyWithin")}}</p>
</div>
<h2 id="Ver_también">Ver también</h2>
<ul>
<li>{{jsxref("Array")}}</li>
</ul>
|
