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/default_parameters/index.html | 225 +++++++++++++++++++++ 1 file changed, 225 insertions(+) create mode 100644 files/pl/web/javascript/reference/functions/default_parameters/index.html (limited to 'files/pl/web/javascript/reference/functions/default_parameters/index.html') 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ż

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