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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
---
title: Object.prototype.__proto__
slug: Web/JavaScript/Referencje/Obiekty/Object/proto
translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto
---
<div class="warning">
<p><strong>Ostrzeżenie:</strong> Zmiana <code>[[Prototype]]</code> obiektu, ze względu na sposób w jaki współczesny JavaScript optymalizuje dostęp do właściwości, jest bardzo powolną operacją (W każdej przeglądarce!). Efekty modyfikacji łańcucha dziedziczenia są rozległe, nie chodzi tu tylko o wydłużenie czasu potrzebnego na wykonanie operacji <code>obj.__proto__ = ...</code>, skutki wpływają na <strong>każdy</strong> fragment kodu który odwołuje się do <strong>jakiejkolwiek</strong> właściwości obiektu, którego <code>[[Prototype]]</code> został zmieniony. Dlatego jeżeli zależy ci na wydajności powinieneś unikać tej operacji. Zamiast tego, stwórz nowy obiekt z porządanym <code>[[Prototype]]</code> za pomocą {{jsxref("Object.create()")}}.</p>
</div>
<div class="warning">
<p><strong>Ostrzeżenie:</strong> Mimo że w dzisiejszych czasach <code>Object.prototype.__proto__</code> jest wspierany w niemal każdej przeglądarce, jego istnienie oraz zachowanie zostały ujednolicone w specyfikacji ECMAScript 2015 jedynie jako <em>legacy feature</em> aby zapewnić kompatybilność z przeglądarkami. Dla lepszego wsparcia rekomenduje się używanie {{jsxref("Object.getPrototypeOf()")}}.</p>
</div>
<div>{{JSRef}}</div>
<p>Właściwość <code>__proto__</code> obiektu {{jsxref("Object.prototype")}} jest operatorem dostępu (metoda getter i setter) która operuje na wewnętrznym <code>[[Prototype]]</code> (na obiekcie lub na {{jsxref("Global_Objects/null", "null")}}) obiektu do którego się odnosi.</p>
<p>Użycie <code>__proto__</code> jest kontrowersyjne i podchodzi się do niego z niechęcią. Oryginalnie nigdy nie pojawiło się w specyfikacji EcmaScript, ale nowoczesne przeglądarki postanowiły mimo wszystko to zaimplementować. Dopiero niedawno właściwość <code>__proto__</code> znalazła swoje miejsce w specyfikacji ECMAScript 2015 aby zapewnić kompatybilność z tymi przeglądarkami. Jest ona jednak przestarzała ze względu na {{jsxref("Object.getPrototypeOf")}}/{{jsxref("Reflect.getPrototypeOf")}} oraz {{jsxref("Object.setPrototypeOf")}}/{{jsxref("Reflect.setPrototypeOf")}} (choć modyfikowanie <code>[[Prototype]]</code> wciąż jest operacją powolną, która powinna być unikana przez wzgląd na wydajność).</p>
<p><code>Właściwość __proto__</code> może być również używana w notacji literałowej aby ustawić <code>[[Prototype]]</code> tworzonego obiektu, jako alterantywa do {{jsxref("Object.create()")}}. Zobacz: <a href="/pl/docs/Web/JavaScript/Reference/Operators/Object_initializer">inicjalizator obiektu / notacja literałowa</a>.</p>
<h2 id="Składnia">Składnia</h2>
<pre class="brush: js">var Kolo = function () {};
var ksztalt = {};
var kolo = new Kolo();
// Ustawianie prototypu obiektu
// ZDEPRECJONOWANE. Używamy tego tylko dla przykładu. NIE RÓB TEGO w prawdziwym kodzie.
ksztalt.__proto__ = kolo;
// Sprawdzenie prototypu obiektu
console.log(ksztalt.__proto__ === kolo); // true
</pre>
<pre class="brush: js">var ksztalt = function () {};
var p =
{
a: function ()
{
console.log('aaa');
}
};
ksztalt.prototype.__proto__ = p;
var kolo = new ksztalt();
kolo.a(); // aaa
console.log(ksztalt.prototype === kolo.__proto__); // true
// albo
var ksztalt = function () {};
var p =
{
a: function ()
{
console.log('aaa');
}
};
var kolo = new ksztalt();
kolo.__proto__ = p;
circle.a(); // aaa
console.log(ksztalt.prototype === kolo.__proto__); // false
// albo
function ksztalt() {};
ksztalt.prototype.a = function ()
{
console.log('aaa');
}
var kolo = new ksztalt();
kolo.a(); // aaa
console.log(kolo.__proto__ === ksztalt.prototype); // true
// albo
var ksztalt = function () {};
ksztalt.prototype.a = function ()
{
console.log('aaa');
}
var kolo =
{
__proto__: ksztalt.prototype
};
kolo.a(); // aaa
console.log(kolo.__proto__ === ksztalt.prototype); // true
</pre>
<p>Uwaga: <code>__proto__</code> zapisujemy jako dwie <em>podłogi</em>, następnie pięć liter "proto", następnie dwie kolejne <em>podłogi</em>.</p>
<h2 id="Opis">Opis</h2>
<p>Metoda getter właściwości <code>__proto__</code> daje nam dostęp do wewnętrznej wartości <code>[[Prototype]]</code> obiektu. Dla obiektów stworzonych przy użyciu literału jest to {{jsxref("Object.prototype")}}. Dla tablic stworzonych przy użyciu literału jest to {{jsxref("Array.prototype")}}. Dla funkcji ta wartość to {{jsxref("Function.prototype")}}. Dla obiektów stworzonych przy użyciu <code>new Funkcja</code>, gdzie <code>Funkcja</code> to jeden z wbudowanych konstruktorów dostarczanych przez JavaScript ({{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("String")}}, i tak dalej — wliczając nowe konstrukotry, które mogą zostać dodane w przyszłości), ta wartość to zawsze <code>Funkcja.prototype</code>. Dla obiektów stworzonych przy użyciu <code>new Funkcja</code>, gdzie <code>Funkcja</code> to funkcja zdefiniowana w kodzie, wartość ta przyjmuje taką samą wartość jak <code>Funkcja.prototype</code>.</p>
<p>Metoda setter właściwości <code>__proto__ </code>umożliwia modyfikowanie <code>[[Prototype]]</code> obiektu. W tym celu obiekt musi być roszerzalny według funkcji {{jsxref("Object.isExtensible()")}}, jeżeli nie jest {{jsxref("Global_Objects/TypeError", "TypeError")}} zostanie wyrzucony. Dostarczana wartość musi być obiektem albo typem {{jsxref("Global_Objects/null", "null")}}. Podanie jakiejkolwiek innej wartości nie zrobi nic.</p>
<p>Aby zrozumieć w jaki sposób prototypy używane są do dziedziczenia, zobacz artykuł o <a href="/pl/docs/Web/JavaScript/dziedziczenie_lancuch_prototypow">dziedziczeniu oraz łańcuchu prototypów</a>.</p>
<p>Właściwość <code>__proto__</code> jest prostym operatorem pamięci na {{jsxref("Object.prototype")}} składającym się z metody getter i setter. Dostęp do właściwości <code>__proto__</code> który ostatecznie konsultuje się z {{jsxref("Object.prototype")}} znajdzie tę właściwość, ale dostęp który nie konsultuje {{jsxref("Object.prototype")}} nie znajdzie jej. Jeżeli jakaś inna właściwość <code>__proto__</code> zostanie znaleziona, zanim {{jsxref("Object.prototype")}} zostanie skonsultowany, to właściwość ta przesłoni tą znalezioną w {{jsxref("Object.prototype")}}.</p>
<h2 id="Specyfikacje">Specyfikacje</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Specification</th>
<th scope="col">Status</th>
<th scope="col">Comment</th>
</tr>
<tr>
<td>{{SpecName('ES2015', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
<td>{{Spec2('ES2015')}}</td>
<td>Dołączony (normatywnie) jako jeden z dodatkowych ECMAScript <em>legacy features</em> dla przeglądarek (zauważ że specyfikacja jedynie ujednoliciła coś, co było już zaimplementowane w przeglądarkach).</td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td> </td>
</tr>
</tbody>
</table>
<h2 id="Kompatybilność_z_przeglądarką">Kompatybilność z przeglądarką</h2>
<div>{{CompatibilityTable}}</div>
<div id="compat-desktop">
<table class="compat-table">
<tbody>
<tr>
<th>Feature</th>
<th>Chrome</th>
<th>Firefox (Gecko)</th>
<th>Internet Explorer</th>
<th>Opera</th>
<th>Safari</th>
</tr>
<tr>
<td>Basic support</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatIE("11")}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
</tr>
</tbody>
</table>
</div>
<div id="compat-mobile">
<table class="compat-table">
<tbody>
<tr>
<th>Feature</th>
<th>Android</th>
<th>Chrome for Android</th>
<th>Firefox Mobile (Gecko)</th>
<th>IE Mobile</th>
<th>Opera Mobile</th>
<th>Safari Mobile</th>
</tr>
<tr>
<td>Basic support</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
</tr>
</tbody>
</table>
</div>
<h2 id="Uwagi_odnośnie_kompatybilności">Uwagi odnośnie kompatybilności</h2>
<p>Mimo, że specyfikacja ECMAScript 2015 określa iż wsparcie dla <code>__proto__</code> jest wymagane <em>tylko</em> dla przeglądarek internetowych (w zasadzie normatywnie), to inne środowiska równieź mogą wspierać tę funkcjonalność.</p>
<h2 id="Zobacz_również">Zobacz również</h2>
<ul>
<li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
<li>{{jsxref("Object.getPrototypeOf()")}}</li>
<li>{{jsxref("Object.setPrototypeOf()")}}</li>
</ul>
|
