8. İşlevler
8.1. [func-01] komut dosyası
Komut dosyası, bir fonksiyona parametrelerin nasıl aktarıldığına odaklanır:
- sayılar, dizeler ve boole değerleri için değer aktarma;
- diziler, literal nesneler ve fonksiyonlar için referansla aktarım;
''use strict';
// fonksiyon parametrelerinin aktarım şekli
// -----------------------sayı - değer yoluyla aktarım
function doSomethingWithNumber(param) {
param++;
console.log("[param inside function]=", param, "[type]=", typeof (param), "[passage par référence]=", param === count);
}
// çağırma kodu
let count = 10;
doSomethingWithNumber(count);
console.log("[count outside function]=", count);
// --------------------- dize - değer yoluyla aktarım
function doSomethingWithString(param) {
param += " xyz"
console.log("[param inside function]=", param, "[type]=", typeof (param), "[passage par référence]=", param === text);
}
// çağırma kodu
let text = "abcd";
doSomethingWithString(text);
console.log("[text outside function]=", text);
// --------------------- boole - değer aktarma
function doSomethingWithBoolean(param) {
param = !param;
console.log("[param inside function]=", param, "[type]=", typeof (param), "[passage par référence]=", param === bool);
}
// çağırma kodu
let bool = true;
doSomethingWithBoolean(bool);
console.log("bool [outside function]=", bool);
// --------------------- dizi - referansla aktarım
function doSomethingWithArray(param) {
param.push(1000);
console.log("[param inside function]=", param, "[type]=", typeof (param), "[passage par référence]=", param === tab);
}
// çağırma kodu
const tab = [10, 20, 30];
doSomethingWithArray(tab);
console.log("[tab outside function]=", tab);
// --------------------- nesne - referansla aktarım
function doSomethingWithObject(param) {
param.unePropriétéNouvelle = "xyz";
console.log("[param inside function]=", param, "[type]=", typeof (param), "[passage par référence]=", param === obj);
}
// çağırma kodu
const obj = [10, 20, 30];
doSomethingWithObject(obj);
console.log("[obj outside function]=", obj);
// --------------------- işlev - referansla aktarım
function doSomethingWithFunction(param) {
// biraz tuhaf ama yine de çalışan bir şey
param.unePropriétéNouvelle = "xyz";
console.log("[param inside function]=", param, "[type]=", typeof (param), "[passage par référence]=", param === f);
}
// çağırma kodu
const f = x => x + 4;
doSomethingWithFunction(f);
console.log("[f outside function]=", f, f.unePropriétéNouvelle, typeof (f));
Çalıştırma
[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe -r esm "c:\Data\st-2019\dev\es6\javascript\fonctions\func-01.js"
[param inside function]= 11 [type]= number [passage par référence]= false
[count outside function]= 10
[param inside function]= abcd xyz [type]= string [passage par référence]= false
[text outside function]= abcd
[param inside function]= false [type]= boolean [passage par référence]= false
bool [outside function]= true
[param inside function]= [ 10, 20, 30, 1000 ] [type]= object [passage par référence]= true
[tab outside function]= [ 10, 20, 30, 1000 ]
[param inside function]= [ 10, 20, 30, 'unePropriétéNouvelle': 'xyz' ] [type]= object [passage par référence]= true
[obj outside function]= [ 10, 20, 30, 'unePropriétéNouvelle': 'xyz' ]
[param inside function]= x => x + 4 [type]= function [passage par référence]= true
[f outside function]= x => x + 4 xyz function
8.2. [func-02] komut dosyası
Aşağıdaki komut dosyası, [function] türünün diğer veri türleri gibi bir veri türü olduğunu ve bir değişkenin bu türe sahip olabileceğini gösterir. Ayrıca, bir işlevi tanımlamanın iki yolunu da gösterir:
- biri [function] anahtar sözcüğüyle;
- diğeri ise “ok” notasyonu => kullanılarak;
''use strict';
// bir değişkene fonksiyon atanabilir
const variable1 = function (a, b) {
return a + b;
};
console.log("typeof(variable1)=", typeof (variable1));
// değişken daha sonra bir fonksiyon gibi kullanılabilir
console.log("variable1(10,12)=", variable1(10, 12));
// fonksiyon tanımı => notasyonu ile yapılabilir
const variable2 = (a, b, c) => {
return a - b + c;
};
console.log("variable2(10,12,14)=", variable2(10, 12, 14));
// fonksiyon kodunda tek bir ifade varsa küme parantezleri kullanılmayabilir
// bu ifade, fonksiyonun dönüş değeri olur
const variable3 = (a, b, c) => a + b + c;
console.log("variable3(10,12,14)=", variable3(10, 12, 14));
Çalıştırma
[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe -r esm "c:\Data\st-2019\dev\es6\javascript\fonctions\func-02.js"
typeof(variable1)= function
variable1(10,12)= 22
variable2(10,12,14)= 12
variable3(10,12,14)= 36
8.3. [func-03] komut dosyası
Bu komut dosyası, bir fonksiyonu başka bir fonksiyona parametre olarak aktarma olasılığını ele almaktadır. Bu yöntem, JavaScript çerçevelerinde yaygın olarak kullanılmaktadır.
''use strict';
// Bir fonksiyonun parametreleri [fonction] türünde olabilir
// f1 fonksiyonu
function f1(param1, param2) {
return param1 + param2 + 10;
}
// f2 işlevi
function f2(param1, param2) {
return param1 + param2 + 20;
}
// f işlevini parametre olarak alan g işlevi
function g(param1, param2, f) {
return f(param1, param2) + 100;
}
// g işlevinin kullanımları
console.log(g(0, 10, f1));
console.log(g(0, 10, f2));
// fonksiyon türündeki etkin parametre doğrudan geçirilebilir - biçim 1
console.log(g(0, 10, (param1, param2) => {
return param1 + param2 + 30;
}));
// fonksiyon türündeki etkin parametre doğrudan aktarılabilir - biçim 2
console.log(g(0, 10, function (param1, param2) {
return param1 + param2 + 40;
}));
Çalıştırma
[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe -r esm "c:\Data\st-2019\dev\es6\javascript\fonctions\func-03.js"
120
130
140
150
8.4. [func-04] betiği
Aşağıdaki betik, bir JavaScript fonksiyonunun bir sınıf gibi davranabileceğini göstermektedir:
'use strict';
// bir işlev nesne olarak kullanılabilir
// boş bir kabuk
function f() {
}
// dışarıdan özellikler atanan
f.prop1 = "val1";
f.show = function () {
console.log(this.prop1);
}
// f işlevinin kullanımı
f.show();
// bir sınıf gibi çalışan g işlevi
function g() {
this.prop2 = "val2";
this.show = function () {
console.log(this.prop2);
}
}
// [new] ile fonksiyonun örneklenmesi
new g().show();
Açıklamalar
- 5-7. satırlar: f işlevinin gövdesi hiçbir özellik tanımlamaz;
- 9-12. satırlar: f işlevine dışarıdan özellikler atanır;
- 14. satır: f fonksiyonunun (nesnesinin) kullanımı. [f()] değil, sadece [f] yazıldığına dikkat edin. Burada bir nesnenin gösterimi kullanılmaktadır;
- satır 17-22: [g] fonksiyonu, sanki özellikleri ve yöntemleri olan bir sınıfmış gibi tanımlanıyor;
- 24. satır: [g] işlevi, [new g()] tarafından örneklenir;
Çalıştırma sonuçları
[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe -r esm "c:\Data\st-2019\dev\es6\javascript\classes\class-00.js"
val1
val2
ES6, artık sınıflar elde etmek için işlevlerden geçmek zorunda kalmamamızı sağlayan sınıf kavramını getirmiştir.
8.5. [func-05] komut dosyası
[func-05] komut dosyası, [rest operator] adlı bir operatörün kullanımını göstermektedir:
'use strict';
// kalan operatörü
function f(arg1, ...otherArgs) {
// 1. argüman
console.log("arg1=", arg1);
// diğer argümanlar
let i = 0;
otherArgs.forEach(element => {
console.log("otherArguments[", i, "]=", element);
i++;
});
}
// çağırma
f(1, "deux", "trois", { x: 2, y: 3 })
- 3. satır: [...otherArgs] notasyonu, f(param1, param2, param3) türünde bir çağrı yapıldığında 3. satırın şöyle olmasını sağlar:
- arg1=param1
- otherArgs=[param2, param3]. Dolayısıyla [otherArgs], [param1]'in arkasına geçirilen tüm etkin parametreleri bir araya getiren bir dizidir;
Uygulamanın sonuçları şunlardır: