From de5c456ebded0e038adbf23db34cc290c8829180 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:49:24 +0100 Subject: unslug pl: move --- .../functions/arguments/callee/index.html | 60 ++++ .../reference/functions/arguments/index.html | 129 ++++++++ .../functions/arguments/length/index.html | 59 ++++ .../reference/functions/arrow_functions/index.html | 355 +++++++++++++++++++++ .../functions/default_parameters/index.html | 225 +++++++++++++ .../functions/funkcje_strzalkowe/index.html | 355 --------------------- .../parametry_domy\305\233lne/index.html" | 225 ------------- 7 files changed, 828 insertions(+), 580 deletions(-) create mode 100644 files/pl/web/javascript/reference/functions/arguments/callee/index.html create mode 100644 files/pl/web/javascript/reference/functions/arguments/index.html create mode 100644 files/pl/web/javascript/reference/functions/arguments/length/index.html create mode 100644 files/pl/web/javascript/reference/functions/arrow_functions/index.html create mode 100644 files/pl/web/javascript/reference/functions/default_parameters/index.html delete mode 100644 files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html delete mode 100644 "files/pl/web/javascript/reference/functions/parametry_domy\305\233lne/index.html" (limited to 'files/pl/web/javascript/reference/functions') diff --git a/files/pl/web/javascript/reference/functions/arguments/callee/index.html b/files/pl/web/javascript/reference/functions/arguments/callee/index.html new file mode 100644 index 0000000000..50b76e1f63 --- /dev/null +++ b/files/pl/web/javascript/reference/functions/arguments/callee/index.html @@ -0,0 +1,60 @@ +--- +title: callee +slug: Web/JavaScript/Referencje/Funkcje/arguments/callee +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Functions/arguments/callee +--- +

+

+

Podsumowanie

+

Określa aktualnie wykonywaną funkcję. +

+ + + + + + + + + + + + +
Własność obiektów arguments i Function.arguments (Wycofywany)
Zaimplementowano w:JavaScript 1.2 +

JavaScript 1.4: callee wycofywany jako własność Function.arguments, zachowany jako własność zmiennej lokalnej arguments funkcji. +

+
Wersja ECMA:ECMA-262
+

Opis

+

callee jest własnością zmiennej lokalnej arguments dostępnej wewnątrz wszystkich obiektów funkcji; callee jako własność Function.arguments nie jest już używana (również sam obiekt Function.arguments jest wycofywany). +

arguments.callee pozwala anonimowym funkcjom odwoływać się do siebie samych, co jest potrzebne w przypadku rekursywnych anonimowych funkcji. +

Słowo kluczowe this nie odwołuje się do aktualnie wykonywanej funkcji. Użyj własności callee, aby odwołać się do funkcji z poziomu jej ciała. +

+

Przykłady

+

Przykład: Zastosowanie arguments.callee w anonimowych funkcjach rekursywnych

+

Funkcja rekursywna musi mieć możliwość odwołania się do siebie samej. Zazwyczaj funkcja odwołuje się do samej siebie wykorzystując swoją nazwę. Jednakże anonimowa funkcja nie posiada nazwy i jeśli w łańcuchu zasięgu nie istnieje zmienna odwołująca się do tej funkcji, tj. funkcja nie jest przypisana do żadnej zmiennej, to funkcja ta nie ma możliwości odwołania się do siebie samej (anonimowe funkcje można tworzyć przy użyciu wyrażenia function lub konstruktora Function). W tym miejscu wkracza arguments.callee. +

Poniższy przykład definiuje funkcję, która z kolei definiuje i zwraca funkcję obliczającą silnię. +

+
function makeFactorialFunc() {
+   alert('tworzenie funkcji obliczającej silnię!');
+   return function(x) {
+      if (x <= 1)
+         return 1;
+      return x * arguments.callee(x - 1);
+   };
+}
+
+var result = makeFactorialFunc()(5); // zwraca 120 (5 * 4 * 3 * 2 * 1)
+
+

this example isn't very practical, but then again, there are few practical cases where arguments.callee is necessary, and most of the those cases involve closures +


+


+


+

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments/callee", "es": "es/Referencia_de_JavaScript_1.5/Funciones/arguments/callee", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments/callee", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments/callee" } ) }} diff --git a/files/pl/web/javascript/reference/functions/arguments/index.html b/files/pl/web/javascript/reference/functions/arguments/index.html new file mode 100644 index 0000000000..8a48b5b323 --- /dev/null +++ b/files/pl/web/javascript/reference/functions/arguments/index.html @@ -0,0 +1,129 @@ +--- +title: arguments +slug: Web/JavaScript/Referencje/Funkcje/arguments +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Functions/arguments +--- +

+

+

Podsumowanie

+

Tablicopodobny obiekt odpowiadający argumentom przekazanym do funkcji. +

+ + + + + + + + + + + + +
+Zmienna lokalna we wszystkich funkcjach oraz wycofywana własność obiektu Function
Zaimplementowana w:JavaScript 1.1, NES 2.0 +

JavaScript 1.2: dodano własność arguments.callee. +

JavaScript 1.3: wycofywana własność arguments.caller; usunięto obsługę nazw argumentów oraz zmiennych lokalnych jako własności obiektu arguments. +

JavaScript 1.4: wycofywane arguments, arguments.callee oraz arguments.length jako własności Function; zachowanie arguments jako lokalnej zmiennej funkcji oraz arguments.callee oraz arguments.length jako własności tej zmiennej. +

+
Wersja ECMA:ECMA-262
+

Opis

+

Obiekt arguments jest zmienną lokalną dostępną wewnątrz każdej funkcji; arguments jako własność Function nie może być już używana. +

Do argumentów wewnątrz funkcji możesz odwołać się używając obiektu arguments. Obiekt ten zawiera pozycję dla każdego argumentu przekazanego funkcji, przy czym indeks pierwszego z nich ma wartość 0. Na przykład, jeśli do funkcji przekazane są trzy argumenty, można się do nich odwołać w następujący sposób: +

+
arguments[0]
+arguments[1]
+arguments[2]
+
+

Argumentom mogą być również przypisywane wartości: +

+
arguments[1] = 'nowa wartosc';
+
+
Uwaga: silnik JavaScript SpiderMonkey posiada bug, w którym nie można do arguments{{ mediawiki.external('n') }} przypisać wartości, jeśli n jest większe niż liczba formalnych lub rzeczywistych parametrów. +Błąd ten został usunięty w silniku JavaScript 1.6.
+

Obiekt arguments nie jest tablicą. Jest do niej podobny, lecz nie posiada żadnej z własności tablicy poza length. Przykładowo nie posiada on metody pop. Może być on jednak skonwertowany do prawdziwej tablicy: +

+
 var args = Array.prototype.slice.call(arguments);
+
+

Obiekt arguments dostępny jest wyłącznie wewnątrz ciała funkcji. Próba dostępu do obiektu arguments spoza części deklaracyjnej funkcji zakończy się błędem. +

Możesz użyć obiektu arguments, jeśli funkcja wywołana jest z większą liczbą argumentów niż zostało to zadeklarowane. Jest to użyteczne dla funkcji, które wywoływać można ze zmienną liczbą argumentów. +Aby określić liczbę argumentów przekazywanych do funkcji można użyć własności +arguments.length, a następnie skorzystać z każdego z argumentów używając obiektu arguments (aby określić liczbę argumentów zadeklarowanych podczas definiowania funkcji, skorzystać można z własności Function.length). +

+

Własności

+
arguments.callee
Określa ciało funkcji aktualnie wykonywanej funkcji. +
+
arguments.caller {{ Deprecated_inline() }}
Określa nazwę funkcji, która wywołała aktualnie wykonywaną funkcję. +
+
arguments.length
Określa liczbę argumentów przekazywanych do funkcji. +
+

Zgodność wsteczna

+

JavaScript 1.3 i wcześniejsze wersje

+

Oprócz dostępności jako zmienna lokalna, obiekt arguments jest również własnością obiektu Function i może być poprzedzony nazwą funkcji. Na przykład, jeżeli do funkcji myFunc są przekazywane trzy argumenty o nazwie arg1, arg2, i arg3, można odwołać się do tych argumentów następująco: +

+
myFunc.arguments[0]
+myFunc.arguments[1]
+myFunc.arguments[2]
+
+

JavaScript 1.1 i 1.2

+

Następujące cechy dostępne w JavaScripcie 1.1 i JavaScripcie 1.2 zostały usunięte: +

+ + +

Przykłady

+

Przykład: Definiowanie funkcji łączącej łańcuchy znaków

+

Ten przykład definiuje funkcję łączącą kilka łańcuchów znaków. Jedynym formalnym argumentem tej funkcji jest łańcuch znaków, który określa znaki oddzielające poszczególne łączone elementy. Funkcja jest zdefiniowana następująco: +

+
function myConcat(separator) {
+   result = ""; // inicjalizacja listy
+   // iteracja pomiędzy argumentami
+   for (var i = 1; i < arguments.length; i++) {
+      result += arguments[i] + separator;
+   }
+   return result;
+}
+
+

Możesz przesłać dowolną liczbę argumentów do tej funkcji, tworząc na ich bazie listę. +

+
// zwraca "czerwony, pomaranczowy, niebieski, "
+myConcat(", ", "czerwony", "pomaranczowy", "niebieski");
+
+// zwraca "slon; zyrafa; lew; gepard; "
+myConcat("; ", "slon", "zyrafa", "lew", "gepard");
+
+// zwraca "szalwia. bazylia. oregano. pieprz. pietruszka. "
+myConcat(". ", "szalwia", "bazylia", "oregano", "pieprz", "pietruszka");
+
+

Przykład: Definiowanie funkcji, która tworzy listę HTML

+

Ten przykład definiuje funkcję, która tworzy łańcuch znaków reprezentujący kod HTML listy. Jedynym argumentem formalnym tej funkcji jest ciąg znaków, który przyjmuje wartość "u" dla listy nieuporządkowanej, lub "o" w przypadku listy uporządkowanej. Funkcja ta jest zdefiniowana następująco: +

+
function list(type) {
+  var result = "<" + type + "l>";
+
+  // iteracja pomiędzy argumentami
+  for (var i = 1; i < arguments.length; i++)
+    result += "<li>" + arguments[i] + "</li>";
+
+  result += "</" + type + "l>"; // koniec listy
+
+  return result;
+}
+
+

Możesz przekazać funkcji dowolną liczbę argumentów, a ona doda każdy z nich jako kolejną pozycję na liście o wskazanym typie. Przykładowo następujące wywołanie funkcji: +

+
var listHTML = list("u", "Raz", "Dwa", "Trzy");
+// listHTML zawiera łańcuch "<ul><li>Raz</li><li>Dwa</li><li>Trzy</li></ul>"
+
+


+


+

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments", "es": "es/Referencia_de_JavaScript_1.5/Funciones/arguments", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments" } ) }} diff --git a/files/pl/web/javascript/reference/functions/arguments/length/index.html b/files/pl/web/javascript/reference/functions/arguments/length/index.html new file mode 100644 index 0000000000..79d54a4f50 --- /dev/null +++ b/files/pl/web/javascript/reference/functions/arguments/length/index.html @@ -0,0 +1,59 @@ +--- +title: length +slug: Web/JavaScript/Referencje/Funkcje/arguments/length +tags: + - Dokumentacja_JavaScript + - Dokumentacje + - JavaScript + - Wszystkie_kategorie +translation_of: Web/JavaScript/Reference/Functions/arguments/length +--- +

+

+

Podsumowanie

+

Określa liczbę argumentów przekazywanych do funkcji. +

+ + + + + + + + + + + + +
Własność obiektów arguments i Function.arguments (wycofywana)
Zaimplementowana w:JavaScript 1.1 +

JavaScript 1.4: Przenaczono do wycofania length jako własność Function.arguments, zachowano ją natomiast jako własność zmiennej lokalnej arguments funkcji. +

+
Wersja ECMA:ECMA-262
+

Opis

+

length jest własnością zmiennej lokalnej arguments dostępnej wewnątrz wszystkich obiektów funkcji; length jako własność Function.arguments nie jest już używana (również sam obiekt Function.arguments jest wycofywany). +

arguments.length dostarcza liczbę argumentów przekazywanych obecnie funkcji. Dla porównania, własność Function.length wskazuje ilość argumentów oczekiwanych przez funkcję. +

+

Przykłady

+

Przykład: Zastosowanie Function.length i arguments.length

+

Następujący przykład przedstawia zastosowanie Function.length i arguments.length. +

+
function addNumbers(x,y){
+   if (arguments.length == addNumbers.length) {
+      return (x+y)
+   }
+   else return 0
+}
+
+

Jeśli podano więcej niż dwa argumenty funkcji, zostanie zwrócona wartość 0: +

+
result=addNumbers(3,4,5)   // zwraca 0
+result=addNumbers(3,4)     // zwraca 7
+result=addNumbers(103,104) // zwraca 207
+
+

Zobacz także

+

Function.length +


+

+
+
+{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Functions/arguments/length", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Fonctions/arguments/length", "ja": "ja/Core_JavaScript_1.5_Reference/Functions/arguments/length" } ) }} diff --git a/files/pl/web/javascript/reference/functions/arrow_functions/index.html b/files/pl/web/javascript/reference/functions/arrow_functions/index.html new file mode 100644 index 0000000000..d1b9d6010f --- /dev/null +++ b/files/pl/web/javascript/reference/functions/arrow_functions/index.html @@ -0,0 +1,355 @@ +--- +title: Funkcje strzałkowe +slug: Web/JavaScript/Reference/Functions/Funkcje_strzalkowe +translation_of: Web/JavaScript/Reference/Functions/Arrow_functions +--- +
{{jsSidebar("Functions")}}
+ +

Funkcja strzałkowa ma krótszą składnię niż zwykłe wyrażenie funkcji oraz nie posiada własnego this, argumentów, super, tudzież właściwości new.target. Taki sposób wyrażenia funkcji najlepiej wykorzystać przy tworzeniu funkcji bez metod, ponadto nie mogą zostać one użyte jako konstruktory.

+ +

Składnia

+ +

Składnia podstawowa

+ +
(param1, param2, …, paramN) => { statements }
+(param1, param2, …, paramN) => expression
+// inaczej mówiąc: (param1, param2, …, paramN) => { return expression; }
+
+// Nawiasy są opcjonalne jeżeli występuje wyłącznie jedna nazwa parametru:
+(singleParam) => { statements }
+singleParam => { statements }
+singleParam => expression
+
+
+// Lista parametrów dla funkcji bez parametrów powinna być zapisana przy użyciu pustego nawiasu.
+() => { statements }
+
+ +

Zaawansowana składnia

+ +
// Otoczenie ciała funkcji nawiasami pozwoli zwrócić tzw. object literal expression:
+params => ({foo: bar})
+
+// Parametry Rest (Rest parameters) i domyślne (default parameters) są wspierane
+(param1, param2, ...rest) => { statements }
+(param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements }
+
+// Destrukturyzacja (Destructuring) w ramach listy parametrów jest również wspierana
+let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
+f();
+// 6
+
+ +

Opis

+ +

Zobacz również "ES6 In Depth: Arrow functions" na hacks.mozilla.org.

+ +

Dwa czynniki, które wpłynęły na wprowadzenie funkcji strzałkowych: krótszy zapis funkcji i brak wiązania this.

+ +

Krótsze funkcje

+ +
var materials = [
+  'Hydrogen',
+  'Helium',
+  'Lithium',
+  'Beryllium'
+];
+
+materials.map(function(material) {
+  return material.length;
+}); // [8, 6, 7, 9]
+
+materials.map((material) => {
+  return material.length;
+}); // [8, 6, 7, 9]
+
+materials.map(material => material.length); // [8, 6, 7, 9]
+
+materials.map(({ length }) => length); // [8, 6, 7, 9]
+
+ +

Brak oddzielnego this

+ +

Przed wprowadzeniem funkcji strzałkowych każda nowa funkcja deniniowała swoją własną wartość this (nowy obiekt w przypadku konstruktora, undefined w wywołaniach funkcji strict mode, obiekt bazowy jeśli funkcja jest wywoływana jako "metoda obiektowa", itp.). Okazało się to niekorzystne przy obiektowym stylu programowania.

+ +
function Person() {
+  // Konstruktor Person() definiuje `this` jako instancję samego siebie.
+  this.age = 0;
+
+  setInterval(function growUp() {
+    // Bez trybu non-strict, funkcja growUp() definuje `this`
+    // jako obiekt globalny, który jest inny od `this`
+    // zdefiniowanego przez konstruktor Person().
+    this.age++;
+  }, 1000);
+}
+
+var p = new Person();
+ +

W ECMAScript 3/5, problem z this można było rozwiązać przez przydzielenie wartości this do zmiennej, która wygląda bardzo podobnie.

+ +
function Person() {
+  var that = this;
+  that.age = 0;
+
+  setInterval(function growUp() {
+    // The callback refers to the `that` variable of which
+    // the value is the expected object.
+    that.age++;
+  }, 1000);
+}
+ +

Można było również stworzyć funkcję bound, co pozwoliło nadać wstępnie przypisaną wartość this do powiązanej funkcji docelowej (funkcja growUp() w przykładzie powyżej).

+ +

Funkcja strzałkowa nie posiada własnego this; używana jest wartość this kontekstu wykonania. W związku z tym, w poniższym kodzie, this użyty w funkcji, który jest przekazywany do setInterval, ma taką samą wartość jak this w funkcji otaczającej:

+ +
function Person(){
+  this.age = 0;
+
+  setInterval(() => {
+    this.age++; // własność |this| właściwie odnosi się do obiektu Person()
+  }, 1000);
+}
+
+var p = new Person();
+ +

Relation with strict mode

+ +

Given that this comes from the surrounding lexical context, strict mode rules with regard to this are ignored.

+ +
var f = () => { 'use strict'; return this; };
+f() === window; // or the global object
+ +

All other strict mode rules apply normally.

+ +

Invoked through call or apply

+ +

Since arrow functions do not have their own this, the methods call() or apply() can only pass in parameters. thisArg is ignored.

+ +
var adder = {
+  base: 1,
+
+  add: function(a) {
+    var f = v => v + this.base;
+    return f(a);
+  },
+
+  addThruCall: function(a) {
+    var f = v => v + this.base;
+    var b = {
+      base: 2
+    };
+
+    return f.call(b, a);
+  }
+};
+
+console.log(adder.add(1));         // This would log to 2
+console.log(adder.addThruCall(1)); // This would log to 2 still
+ +

No binding of arguments

+ +

Arrow functions do not have their own arguments object. Thus, in this example, arguments is simply a reference to the the arguments of the enclosing scope:

+ +
var arguments = [1, 2, 3];
+var arr = () => arguments[0];
+
+arr(); // 1
+
+function foo(n) {
+  var f = () => arguments[0] + n; // foo's implicit arguments binding. arguments[0] is n
+  return f(10);
+}
+
+foo(1); // 2
+ +

In most cases, using rest parameters is a good alternative to using an arguments object.

+ +
function foo(n) {
+  var f = (...args) => args[0] + n;
+  return f(10);
+}
+
+foo(1); // 11
+ +

Arrow functions used as methods

+ +

As stated previously, arrow function expressions are best suited for non-method functions. Let's see what happens when we try to use them as methods:

+ +
'use strict';
+var obj = {
+  i: 10,
+  b: () => console.log(this.i, this),
+  c: function() {
+    console.log(this.i, this);
+  }
+}
+obj.b(); // prints undefined, Window {...} (or the global object)
+obj.c(); // prints 10, Object {...}
+ +

Arrow functions do not have their own this. Another example involving {{jsxref("Object.defineProperty()")}}:

+ +
'use strict';
+var obj = {
+  a: 10
+};
+
+Object.defineProperty(obj, 'b', {
+  get: () => {
+    console.log(this.a, typeof this.a, this);
+    return this.a + 10; // represents global object 'Window', therefore 'this.a' returns 'undefined'
+  }
+});
+
+ +

Use of the new operator

+ +

Arrow functions cannot be used as constructors and will throw an error when used with new.

+ +
var Foo = () => {};
+var foo = new Foo(); // TypeError: Foo is not a constructor
+ +

Use of prototype property

+ +

Arrow functions do not have a prototype property.

+ +
var Foo = () => {};
+console.log(Foo.prototype); // undefined
+
+ +

Use of the yield keyword

+ +

The yield keyword may not be used in an arrow function's body (except when permitted within functions further nested within it). As a consequence, arrow functions cannot be used as generators.

+ +

Function body

+ +

Arrow functions can have either a "concise body" or the usual "block body".

+ +

In a concise body, only an expression is specified, which becomes the explicit return value. In a block body, you must use an explicit return statement.

+ +
var func = x => x * x;
+// concise body syntax, implied "return"
+
+var func = (x, y) => { return x + y; };
+// with block body, explicit "return" needed
+
+ +

Returning object literals

+ +

Keep in mind that returning object literals using the concise body syntax params => {object:literal} will not work as expected.

+ +
var func = () => { foo: 1 };
+// Calling func() returns undefined!
+
+var func = () => { foo: function() {} };
+// SyntaxError: function statement requires a name
+ +

This is because the code inside braces ({}) is parsed as a sequence of statements (i.e. foo is treated like a label, not a key in an object literal).

+ +

Remember to wrap the object literal in parentheses.

+ +
var func = () => ({foo: 1});
+ +

Line breaks

+ +

An arrow function cannot contain a line break between its parameters and its arrow.

+ +
var func = ()
+           => 1;
+// SyntaxError: expected expression, got '=>'
+ +

Parsing order

+ +

Although the arrow in an arrow function is not an operator, arrow functions have special parsing rules that interact differently with operator precedence compared to regular functions.

+ +
let callback;
+
+callback = callback || function() {}; // ok
+
+callback = callback || () => {};
+// SyntaxError: invalid arrow-function arguments
+
+callback = callback || (() => {});    // ok
+
+ +

More examples

+ +
// An empty arrow function returns undefined
+let empty = () => {};
+
+(() => 'foobar')();
+// Returns "foobar"
+// (this is an Immediately Invoked Function Expression
+// see 'IIFE' in glossary)
+
+var simple = a => a > 15 ? 15 : a;
+simple(16); // 15
+simple(10); // 10
+
+let max = (a, b) => a > b ? a : b;
+
+// Easy array filtering, mapping, ...
+
+var arr = [5, 6, 13, 0, 1, 18, 23];
+
+var sum = arr.reduce((a, b) => a + b);
+// 66
+
+var even = arr.filter(v => v % 2 == 0);
+// [6, 0, 18]
+
+var double = arr.map(v => v * 2);
+// [10, 12, 26, 0, 2, 36, 46]
+
+// More concise promise chains
+promise.then(a => {
+  // ...
+}).then(b => {
+  // ...
+});
+
+// Parameterless arrow functions that are visually easier to parse
+setTimeout( () => {
+  console.log('I happen sooner');
+  setTimeout( () => {
+    // deeper code
+    console.log('I happen later');
+  }, 1);
+}, 1);
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ +
+ + +

{{Compat("javascript.functions.arrow_functions")}}

+
+ +

See also

+ + diff --git a/files/pl/web/javascript/reference/functions/default_parameters/index.html b/files/pl/web/javascript/reference/functions/default_parameters/index.html new file mode 100644 index 0000000000..b192456adf --- /dev/null +++ b/files/pl/web/javascript/reference/functions/default_parameters/index.html @@ -0,0 +1,225 @@ +--- +title: Parametry domyślne +slug: Web/JavaScript/Reference/Functions/Parametry_domyślne +tags: + - ECMAScript2015 + - Funkcje + - JavaScript +translation_of: Web/JavaScript/Reference/Functions/Default_parameters +--- +
{{jsSidebar("Functions")}}
+ +

Domyślne parametry funkcji pozwalają na inicjalizację nazwanych parametrów wartościami domyślnymi tam, gdzie nie została podana żadna wartość lub jako wartość podano undefined.

+ +
{{EmbedInteractiveExample("pages/js/functions-default.html")}}
+ + + +

Składnia

+ +
function [nazwa]([parametr1[ = domyślnaWartość1 ][, ..., parametrN[ = domyślnaWartośćN ]]]) {
+   ciało funkcji
+}
+
+ +

Opis

+ +

W języku JavaScript domyślną wartością parametrów funkcji jest {{jsxref("undefined")}}. Często jednak dobrze jest ustawić inną wartość domyślną – wówczas parametry domyślne okazują się pomocne.

+ +

W przeszłości, ogólną strategią na ustawianie domyślnych wartości było sprawdzanie parametrów w ciele funkcji – w sytuacji, w których były one równe undefined, przypisywano im konkretne wartości.

+ +

W następującym przykładzie, jeśli żadna wartość nie jest podana jako b, kiedy wywoływana jest funkcja pomnóż, wartość b powinna być równa undefined – wówczas funkcja powinna zwrócić NaN jako wynik operacji a * b.

+ +
function pomnóż(a, b) {
+  return a * b;
+}
+
+pomnóż(5, 2); // 10
+pomnóż(5);    // NaN !
+
+ +

Aby się przed tym uchronić, należy użyć czegoś takiego, jak w drugiej linijce, gdzie wartość b jest ustawiana na 1, jeśli funkcja pomnóż jest wywoływana tylko z jednym argumentem.

+ +
function pomnóż(a, b) {
+  b = (typeof b !== 'undefined') ?  b : 1;
+  return a * b;
+}
+
+pomnóż(5, 2); // 10
+pomnóż(5);    // 5
+
+ +

Dzięki parametrom domyślnym w ES2015, tego rodzaju sprawdzanie wartości parametrów w ciele funkcji nie jest już konieczne. Można teraz przypisać 1 jako domyślną wartość w nagłówku funkcji:

+ +
function pomnóż(a, b = 1) {
+  return a * b;
+}
+
+pomnóż(5, 2); // 10
+pomnóż(5);    // 5
+
+ +

Przykłady

+ +

Przekazywanie undefined kontra inne puste wartości

+ +

W drugim wywołaniu funkcji w tym przykłądzie, nawet jeśli jako pierwszy argument wprost podany undefined (jednak nie null lub inne puste wartości), wartością argumentu num dalej będzie wartość domyślna.

+ +
function test(num = 1) {
+  console.log(typeof num);
+}
+
+test();          // 'number' (num jest ustawiany na 1)
+test(undefined); // 'number' (num również jest ustawiany na 1)
+
+// test z innymi "pustymi" wartościami:
+test('');        // 'string' (num jest ustawiany na '')
+test(null);      // 'object' (num jest ustawiany na null)
+
+ +

Ewaluacja w czasie wykonania

+ +

Domyślne argumenty są przypisywane w czasie wykonania, a więc w odróżnieniu od np. Pythona, nowy obiekt jest tworzony przy każdym wywołaniu funkcji.

+ +
function append(wartość, tablica = []) {
+  array.push(wartość);
+  return tablica;
+}
+
+append(1); //[1]
+append(2); //[2], nie [1, 2]
+
+ +

Dotyczy to również funkcji i zmiennych:

+ +
function callSomething(thing = something()) {
+ return thing;
+}
+
+let numberOfTimesCalled = 0;
+function something() {
+  numberOfTimesCalled += 1;
+  return numberOfTimesCalled;
+}
+
+callSomething(); // 1
+callSomething(); // 2
+ +

Domyślne parametry są dostępne dla późniejszych domyślnych parametrów

+ +

Parametry zdefiniowane wcześniej (bardziej na lewo na liście parametrów), są dostępne dla domyślnych parametrów definiowanych później:

+ +
function pozdrów(imię, pozdrowienie, wiadomość = pozdrowienie + ' ' + imię) {
+    return [imię, pozdrowienie, wiadomość];
+}
+
+pozdrów('Dawid', 'Cześć');  // ["Dawid", "Cześć", "Cześć Dawid"]
+pozdrów('Dawid', 'Cześć', 'Wszystkiego najlepszego!');  // ["Dawid", "Cześć", "Wszystkiego najlepszego!"]
+
+ +

Ta funkcjonalność może być przybliżona w ten sposób, pokazujący, jak wiele przypadków brzegowych może być obsłużonych:

+ +
function go() {
+  return ':P';
+}
+
+function withDefaults(a, b = 5, c = b, d = go(), e = this,
+                      f = arguments, g = this.value) {
+  return [a, b, c, d, e, f, g];
+}
+
+function withoutDefaults(a, b, c, d, e, f, g) {
+  switch (arguments.length) {
+    case 0:
+      a;
+    case 1:
+      b = 5;
+    case 2:
+      c = b;
+    case 3:
+      d = go();
+    case 4:
+      e = this;
+    case 5:
+      f = arguments;
+    case 6:
+      g = this.value;
+    default:
+  }
+  return [a, b, c, d, e, f, g];
+}
+
+withDefaults.call({value: '=^_^='});
+// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
+
+withoutDefaults.call({value: '=^_^='});
+// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
+
+ +

Funkcje definiowane w ciele funkcji

+ +

Wprowadzone w Gecko 33 {{geckoRelease(33)}}. Funkcje deklarowane w ciele funkcji nie mogą być używane jako wartości domyślne w tej samej funkcji. Przy takiej próbie, wyrzucany jest jest {{jsxref("ReferenceError")}}. Parametr domyślny zawsze wykonywany jest jako pierwszy, a więc deklaracje w ciele funkcji są ewaluowane później.

+ +
// Nie działa! Wyrzuca ReferenceError.
+function f(a = go()) {
+  function go() { return ':P'; }
+}
+
+ +

Parametry bez wartości domyślnych po parametrach domyślnych

+ +

Przed Gecko 26 {{geckoRelease(26)}}, poniższy kod zwracał {{jsxref("SyntaxError")}}. Zostało to naprawione w {{bug(777060)}}. Wartości parametrów dalej są ustawiane w kolejności od lewej do prawej, nadpisując domyślne parametry, nawet jeśli występują potem parametry bez wartości domyślnych.

+ +
function f(x = 1, y) {
+  return [x, y];
+}
+
+f(); // [1, undefined]
+f(2); // [2, undefined]
+
+ +

Parametr destrukturyzowany z przypisaniem domyślnej wartości

+ +

Możesz też użyć przypisania domyślnej wartości z notacją parametru destruktyryzowanego:

+ +
function f([x, y] = [1, 2], {z: z} = {z: 3}) {
+  return x + y + z;
+}
+
+f(); // 6
+ +

Specyfikacje

+ + + + + + + + + + + + + + + + + + + +
SpecyfikacjaStatusKomentarz
{{SpecName('ES2015', '#sec-function-definitions', 'Function Definitions')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}{{Spec2('ESDraft')}}
+ +

Wsparcie przeglądarek

+ +
+ + +

{{Compat("javascript.functions.default_parameters")}}

+
+ +

Zobacz też

+ + diff --git a/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html b/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html deleted file mode 100644 index d1b9d6010f..0000000000 --- a/files/pl/web/javascript/reference/functions/funkcje_strzalkowe/index.html +++ /dev/null @@ -1,355 +0,0 @@ ---- -title: Funkcje strzałkowe -slug: Web/JavaScript/Reference/Functions/Funkcje_strzalkowe -translation_of: Web/JavaScript/Reference/Functions/Arrow_functions ---- -
{{jsSidebar("Functions")}}
- -

Funkcja strzałkowa ma krótszą składnię niż zwykłe wyrażenie funkcji oraz nie posiada własnego this, argumentów, super, tudzież właściwości new.target. Taki sposób wyrażenia funkcji najlepiej wykorzystać przy tworzeniu funkcji bez metod, ponadto nie mogą zostać one użyte jako konstruktory.

- -

Składnia

- -

Składnia podstawowa

- -
(param1, param2, …, paramN) => { statements }
-(param1, param2, …, paramN) => expression
-// inaczej mówiąc: (param1, param2, …, paramN) => { return expression; }
-
-// Nawiasy są opcjonalne jeżeli występuje wyłącznie jedna nazwa parametru:
-(singleParam) => { statements }
-singleParam => { statements }
-singleParam => expression
-
-
-// Lista parametrów dla funkcji bez parametrów powinna być zapisana przy użyciu pustego nawiasu.
-() => { statements }
-
- -

Zaawansowana składnia

- -
// Otoczenie ciała funkcji nawiasami pozwoli zwrócić tzw. object literal expression:
-params => ({foo: bar})
-
-// Parametry Rest (Rest parameters) i domyślne (default parameters) są wspierane
-(param1, param2, ...rest) => { statements }
-(param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements }
-
-// Destrukturyzacja (Destructuring) w ramach listy parametrów jest również wspierana
-let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
-f();
-// 6
-
- -

Opis

- -

Zobacz również "ES6 In Depth: Arrow functions" na hacks.mozilla.org.

- -

Dwa czynniki, które wpłynęły na wprowadzenie funkcji strzałkowych: krótszy zapis funkcji i brak wiązania this.

- -

Krótsze funkcje

- -
var materials = [
-  'Hydrogen',
-  'Helium',
-  'Lithium',
-  'Beryllium'
-];
-
-materials.map(function(material) {
-  return material.length;
-}); // [8, 6, 7, 9]
-
-materials.map((material) => {
-  return material.length;
-}); // [8, 6, 7, 9]
-
-materials.map(material => material.length); // [8, 6, 7, 9]
-
-materials.map(({ length }) => length); // [8, 6, 7, 9]
-
- -

Brak oddzielnego this

- -

Przed wprowadzeniem funkcji strzałkowych każda nowa funkcja deniniowała swoją własną wartość this (nowy obiekt w przypadku konstruktora, undefined w wywołaniach funkcji strict mode, obiekt bazowy jeśli funkcja jest wywoływana jako "metoda obiektowa", itp.). Okazało się to niekorzystne przy obiektowym stylu programowania.

- -
function Person() {
-  // Konstruktor Person() definiuje `this` jako instancję samego siebie.
-  this.age = 0;
-
-  setInterval(function growUp() {
-    // Bez trybu non-strict, funkcja growUp() definuje `this`
-    // jako obiekt globalny, który jest inny od `this`
-    // zdefiniowanego przez konstruktor Person().
-    this.age++;
-  }, 1000);
-}
-
-var p = new Person();
- -

W ECMAScript 3/5, problem z this można było rozwiązać przez przydzielenie wartości this do zmiennej, która wygląda bardzo podobnie.

- -
function Person() {
-  var that = this;
-  that.age = 0;
-
-  setInterval(function growUp() {
-    // The callback refers to the `that` variable of which
-    // the value is the expected object.
-    that.age++;
-  }, 1000);
-}
- -

Można było również stworzyć funkcję bound, co pozwoliło nadać wstępnie przypisaną wartość this do powiązanej funkcji docelowej (funkcja growUp() w przykładzie powyżej).

- -

Funkcja strzałkowa nie posiada własnego this; używana jest wartość this kontekstu wykonania. W związku z tym, w poniższym kodzie, this użyty w funkcji, który jest przekazywany do setInterval, ma taką samą wartość jak this w funkcji otaczającej:

- -
function Person(){
-  this.age = 0;
-
-  setInterval(() => {
-    this.age++; // własność |this| właściwie odnosi się do obiektu Person()
-  }, 1000);
-}
-
-var p = new Person();
- -

Relation with strict mode

- -

Given that this comes from the surrounding lexical context, strict mode rules with regard to this are ignored.

- -
var f = () => { 'use strict'; return this; };
-f() === window; // or the global object
- -

All other strict mode rules apply normally.

- -

Invoked through call or apply

- -

Since arrow functions do not have their own this, the methods call() or apply() can only pass in parameters. thisArg is ignored.

- -
var adder = {
-  base: 1,
-
-  add: function(a) {
-    var f = v => v + this.base;
-    return f(a);
-  },
-
-  addThruCall: function(a) {
-    var f = v => v + this.base;
-    var b = {
-      base: 2
-    };
-
-    return f.call(b, a);
-  }
-};
-
-console.log(adder.add(1));         // This would log to 2
-console.log(adder.addThruCall(1)); // This would log to 2 still
- -

No binding of arguments

- -

Arrow functions do not have their own arguments object. Thus, in this example, arguments is simply a reference to the the arguments of the enclosing scope:

- -
var arguments = [1, 2, 3];
-var arr = () => arguments[0];
-
-arr(); // 1
-
-function foo(n) {
-  var f = () => arguments[0] + n; // foo's implicit arguments binding. arguments[0] is n
-  return f(10);
-}
-
-foo(1); // 2
- -

In most cases, using rest parameters is a good alternative to using an arguments object.

- -
function foo(n) {
-  var f = (...args) => args[0] + n;
-  return f(10);
-}
-
-foo(1); // 11
- -

Arrow functions used as methods

- -

As stated previously, arrow function expressions are best suited for non-method functions. Let's see what happens when we try to use them as methods:

- -
'use strict';
-var obj = {
-  i: 10,
-  b: () => console.log(this.i, this),
-  c: function() {
-    console.log(this.i, this);
-  }
-}
-obj.b(); // prints undefined, Window {...} (or the global object)
-obj.c(); // prints 10, Object {...}
- -

Arrow functions do not have their own this. Another example involving {{jsxref("Object.defineProperty()")}}:

- -
'use strict';
-var obj = {
-  a: 10
-};
-
-Object.defineProperty(obj, 'b', {
-  get: () => {
-    console.log(this.a, typeof this.a, this);
-    return this.a + 10; // represents global object 'Window', therefore 'this.a' returns 'undefined'
-  }
-});
-
- -

Use of the new operator

- -

Arrow functions cannot be used as constructors and will throw an error when used with new.

- -
var Foo = () => {};
-var foo = new Foo(); // TypeError: Foo is not a constructor
- -

Use of prototype property

- -

Arrow functions do not have a prototype property.

- -
var Foo = () => {};
-console.log(Foo.prototype); // undefined
-
- -

Use of the yield keyword

- -

The yield keyword may not be used in an arrow function's body (except when permitted within functions further nested within it). As a consequence, arrow functions cannot be used as generators.

- -

Function body

- -

Arrow functions can have either a "concise body" or the usual "block body".

- -

In a concise body, only an expression is specified, which becomes the explicit return value. In a block body, you must use an explicit return statement.

- -
var func = x => x * x;
-// concise body syntax, implied "return"
-
-var func = (x, y) => { return x + y; };
-// with block body, explicit "return" needed
-
- -

Returning object literals

- -

Keep in mind that returning object literals using the concise body syntax params => {object:literal} will not work as expected.

- -
var func = () => { foo: 1 };
-// Calling func() returns undefined!
-
-var func = () => { foo: function() {} };
-// SyntaxError: function statement requires a name
- -

This is because the code inside braces ({}) is parsed as a sequence of statements (i.e. foo is treated like a label, not a key in an object literal).

- -

Remember to wrap the object literal in parentheses.

- -
var func = () => ({foo: 1});
- -

Line breaks

- -

An arrow function cannot contain a line break between its parameters and its arrow.

- -
var func = ()
-           => 1;
-// SyntaxError: expected expression, got '=>'
- -

Parsing order

- -

Although the arrow in an arrow function is not an operator, arrow functions have special parsing rules that interact differently with operator precedence compared to regular functions.

- -
let callback;
-
-callback = callback || function() {}; // ok
-
-callback = callback || () => {};
-// SyntaxError: invalid arrow-function arguments
-
-callback = callback || (() => {});    // ok
-
- -

More examples

- -
// An empty arrow function returns undefined
-let empty = () => {};
-
-(() => 'foobar')();
-// Returns "foobar"
-// (this is an Immediately Invoked Function Expression
-// see 'IIFE' in glossary)
-
-var simple = a => a > 15 ? 15 : a;
-simple(16); // 15
-simple(10); // 10
-
-let max = (a, b) => a > b ? a : b;
-
-// Easy array filtering, mapping, ...
-
-var arr = [5, 6, 13, 0, 1, 18, 23];
-
-var sum = arr.reduce((a, b) => a + b);
-// 66
-
-var even = arr.filter(v => v % 2 == 0);
-// [6, 0, 18]
-
-var double = arr.map(v => v * 2);
-// [10, 12, 26, 0, 2, 36, 46]
-
-// More concise promise chains
-promise.then(a => {
-  // ...
-}).then(b => {
-  // ...
-});
-
-// Parameterless arrow functions that are visually easier to parse
-setTimeout( () => {
-  console.log('I happen sooner');
-  setTimeout( () => {
-    // deeper code
-    console.log('I happen later');
-  }, 1);
-}, 1);
-
- -

Specifications

- - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES2015', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}{{Spec2('ESDraft')}} 
- -

Browser compatibility

- -
- - -

{{Compat("javascript.functions.arrow_functions")}}

-
- -

See also

- - diff --git "a/files/pl/web/javascript/reference/functions/parametry_domy\305\233lne/index.html" "b/files/pl/web/javascript/reference/functions/parametry_domy\305\233lne/index.html" deleted file mode 100644 index b192456adf..0000000000 --- "a/files/pl/web/javascript/reference/functions/parametry_domy\305\233lne/index.html" +++ /dev/null @@ -1,225 +0,0 @@ ---- -title: Parametry domyślne -slug: Web/JavaScript/Reference/Functions/Parametry_domyślne -tags: - - ECMAScript2015 - - Funkcje - - JavaScript -translation_of: Web/JavaScript/Reference/Functions/Default_parameters ---- -
{{jsSidebar("Functions")}}
- -

Domyślne parametry funkcji pozwalają na inicjalizację nazwanych parametrów wartościami domyślnymi tam, gdzie nie została podana żadna wartość lub jako wartość podano undefined.

- -
{{EmbedInteractiveExample("pages/js/functions-default.html")}}
- - - -

Składnia

- -
function [nazwa]([parametr1[ = domyślnaWartość1 ][, ..., parametrN[ = domyślnaWartośćN ]]]) {
-   ciało funkcji
-}
-
- -

Opis

- -

W języku JavaScript domyślną wartością parametrów funkcji jest {{jsxref("undefined")}}. Często jednak dobrze jest ustawić inną wartość domyślną – wówczas parametry domyślne okazują się pomocne.

- -

W przeszłości, ogólną strategią na ustawianie domyślnych wartości było sprawdzanie parametrów w ciele funkcji – w sytuacji, w których były one równe undefined, przypisywano im konkretne wartości.

- -

W następującym przykładzie, jeśli żadna wartość nie jest podana jako b, kiedy wywoływana jest funkcja pomnóż, wartość b powinna być równa undefined – wówczas funkcja powinna zwrócić NaN jako wynik operacji a * b.

- -
function pomnóż(a, b) {
-  return a * b;
-}
-
-pomnóż(5, 2); // 10
-pomnóż(5);    // NaN !
-
- -

Aby się przed tym uchronić, należy użyć czegoś takiego, jak w drugiej linijce, gdzie wartość b jest ustawiana na 1, jeśli funkcja pomnóż jest wywoływana tylko z jednym argumentem.

- -
function pomnóż(a, b) {
-  b = (typeof b !== 'undefined') ?  b : 1;
-  return a * b;
-}
-
-pomnóż(5, 2); // 10
-pomnóż(5);    // 5
-
- -

Dzięki parametrom domyślnym w ES2015, tego rodzaju sprawdzanie wartości parametrów w ciele funkcji nie jest już konieczne. Można teraz przypisać 1 jako domyślną wartość w nagłówku funkcji:

- -
function pomnóż(a, b = 1) {
-  return a * b;
-}
-
-pomnóż(5, 2); // 10
-pomnóż(5);    // 5
-
- -

Przykłady

- -

Przekazywanie undefined kontra inne puste wartości

- -

W drugim wywołaniu funkcji w tym przykłądzie, nawet jeśli jako pierwszy argument wprost podany undefined (jednak nie null lub inne puste wartości), wartością argumentu num dalej będzie wartość domyślna.

- -
function test(num = 1) {
-  console.log(typeof num);
-}
-
-test();          // 'number' (num jest ustawiany na 1)
-test(undefined); // 'number' (num również jest ustawiany na 1)
-
-// test z innymi "pustymi" wartościami:
-test('');        // 'string' (num jest ustawiany na '')
-test(null);      // 'object' (num jest ustawiany na null)
-
- -

Ewaluacja w czasie wykonania

- -

Domyślne argumenty są przypisywane w czasie wykonania, a więc w odróżnieniu od np. Pythona, nowy obiekt jest tworzony przy każdym wywołaniu funkcji.

- -
function append(wartość, tablica = []) {
-  array.push(wartość);
-  return tablica;
-}
-
-append(1); //[1]
-append(2); //[2], nie [1, 2]
-
- -

Dotyczy to również funkcji i zmiennych:

- -
function callSomething(thing = something()) {
- return thing;
-}
-
-let numberOfTimesCalled = 0;
-function something() {
-  numberOfTimesCalled += 1;
-  return numberOfTimesCalled;
-}
-
-callSomething(); // 1
-callSomething(); // 2
- -

Domyślne parametry są dostępne dla późniejszych domyślnych parametrów

- -

Parametry zdefiniowane wcześniej (bardziej na lewo na liście parametrów), są dostępne dla domyślnych parametrów definiowanych później:

- -
function pozdrów(imię, pozdrowienie, wiadomość = pozdrowienie + ' ' + imię) {
-    return [imię, pozdrowienie, wiadomość];
-}
-
-pozdrów('Dawid', 'Cześć');  // ["Dawid", "Cześć", "Cześć Dawid"]
-pozdrów('Dawid', 'Cześć', 'Wszystkiego najlepszego!');  // ["Dawid", "Cześć", "Wszystkiego najlepszego!"]
-
- -

Ta funkcjonalność może być przybliżona w ten sposób, pokazujący, jak wiele przypadków brzegowych może być obsłużonych:

- -
function go() {
-  return ':P';
-}
-
-function withDefaults(a, b = 5, c = b, d = go(), e = this,
-                      f = arguments, g = this.value) {
-  return [a, b, c, d, e, f, g];
-}
-
-function withoutDefaults(a, b, c, d, e, f, g) {
-  switch (arguments.length) {
-    case 0:
-      a;
-    case 1:
-      b = 5;
-    case 2:
-      c = b;
-    case 3:
-      d = go();
-    case 4:
-      e = this;
-    case 5:
-      f = arguments;
-    case 6:
-      g = this.value;
-    default:
-  }
-  return [a, b, c, d, e, f, g];
-}
-
-withDefaults.call({value: '=^_^='});
-// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
-
-withoutDefaults.call({value: '=^_^='});
-// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
-
- -

Funkcje definiowane w ciele funkcji

- -

Wprowadzone w Gecko 33 {{geckoRelease(33)}}. Funkcje deklarowane w ciele funkcji nie mogą być używane jako wartości domyślne w tej samej funkcji. Przy takiej próbie, wyrzucany jest jest {{jsxref("ReferenceError")}}. Parametr domyślny zawsze wykonywany jest jako pierwszy, a więc deklaracje w ciele funkcji są ewaluowane później.

- -
// Nie działa! Wyrzuca ReferenceError.
-function f(a = go()) {
-  function go() { return ':P'; }
-}
-
- -

Parametry bez wartości domyślnych po parametrach domyślnych

- -

Przed Gecko 26 {{geckoRelease(26)}}, poniższy kod zwracał {{jsxref("SyntaxError")}}. Zostało to naprawione w {{bug(777060)}}. Wartości parametrów dalej są ustawiane w kolejności od lewej do prawej, nadpisując domyślne parametry, nawet jeśli występują potem parametry bez wartości domyślnych.

- -
function f(x = 1, y) {
-  return [x, y];
-}
-
-f(); // [1, undefined]
-f(2); // [2, undefined]
-
- -

Parametr destrukturyzowany z przypisaniem domyślnej wartości

- -

Możesz też użyć przypisania domyślnej wartości z notacją parametru destruktyryzowanego:

- -
function f([x, y] = [1, 2], {z: z} = {z: 3}) {
-  return x + y + z;
-}
-
-f(); // 6
- -

Specyfikacje

- - - - - - - - - - - - - - - - - - - -
SpecyfikacjaStatusKomentarz
{{SpecName('ES2015', '#sec-function-definitions', 'Function Definitions')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}{{Spec2('ESDraft')}}
- -

Wsparcie przeglądarek

- -
- - -

{{Compat("javascript.functions.default_parameters")}}

-
- -

Zobacz też

- - -- cgit v1.2.3-54-g00ecf