En büyük değeri döndüren bir javascript işlevi. JavaScript: İşlevler

Son güncelleme: 04/09/2018

İşlevler, belirli bir eylemi gerçekleştiren veya belirli bir değeri hesaplayan bir dizi talimattır.

İşlev tanımı sözdizimi:

function function_name([parametre [, ...]])( // Talimatlar )

Bir fonksiyon tanımı, function anahtar sözcüğü ile başlar ve ardından işlevin adı gelir. İşlev adı, değişken adıyla aynı kurallara uyar: yalnızca sayılar, harfler, alt çizgiler ve dolar işaretleri ($) içerebilir ve bir harf, alt çizgi veya dolar işaretiyle başlamalıdır.

İşlev adının ardından parantez içindeki bir parametre listesi gelir. İşlevin parametresi olmasa bile, boş parantezler gider. Ardından, süslü parantezler içinde, bir dizi talimat içeren fonksiyonun gövdesi gelir.

En basit fonksiyonu tanımlayalım:

İşlev ekranı()( document.write("JavaScript'te işlev"); )

Bu fonksiyona display() denir. Hiçbir parametre almaz ve yaptığı tek şey web sayfasına bir dize yazmaktır.

Ancak, sadece bir işlevi tanımlamak, onu çalıştırmak için yeterli değildir. Hala aramanız gerekiyor:

Fonksiyonlara belirli bir isim vermek gerekli değildir. Anonim işlevleri kullanabilirsiniz:

Var display = function()( // işlev tanımı document.write("JavaScript işlevi"); ) display();

Aslında, görüntüleme değişkenini tanımlar ve ona bir işlev referansı atarız. Ve sonra işlev, değişkenin adıyla çağrılır.

Ayrıca bir değişkene dinamik olarak işlevler atayabiliriz:

function goodMorning()( document.write("Günaydın"); ) function goodAkşamlar()( document.write("İyi akşamlar"); ) var mesaj = günaydın; İleti(); // Günaydın mesajı = iyiAkşamlar; İleti(); // İyi akşamlar

fonksiyon parametreleri

Parametreleri geçirmeyi düşünün:

fonksiyon display(x)( // fonksiyon tanımı var z = x * x; document.write(x + " kare eşittir " + z); ) display(5); // işlev çağrısı

Görüntüleme işlevi bir parametre alır, x. Bu nedenle, bir işlevi çağırırken, bu durumda olduğu gibi, örneğin 5 rakamı gibi bir değer iletebiliriz.

Bir işlev birden fazla parametre alıyorsa, yayılma operatörünü kullanarak... bu parametreler için bir diziden bir dizi değer iletebiliriz:

fonksiyon toplam(a, b, c)( let d = a + b + c; console.log(d); ) toplam(1, 2, 3); sayilar = ; toplam(...sayılar);

İkinci durumda, nums dizisindeki sayılar işleve iletilir. Ancak sadece bir diziyi tek bir değer olarak değil, tam olarak bu diziden sayıları aktarmak için yayılma operatörü (üç nokta ...) kullanılır.

İsteğe bağlı parametreler

Bir işlev birçok parametre alabilir, ancak parametrelerin bir kısmı veya tamamı isteğe bağlı olabilir. Parametreler için herhangi bir değer iletilmezse, bunlar varsayılan olarak "tanımsız" olur.

işlev display(x, y)( if(y === undefined) y = 5; if(x === undefined) x = 8; let z = x * y; console.log(z); ) display() ; // 40 görüntü(6); // 30 göster(6, 4) // 24

Burada görüntüleme işlevi iki parametre alır. Bir fonksiyonu çağırırken değerlerini kontrol edebiliriz. Aynı zamanda fonksiyon çağrılırken bu parametreler için değer geçmesine gerek yoktur. Bir parametre değerinin varlığını kontrol etmek için tanımsız değerle bir karşılaştırma kullanılır.

Varsayılan parametreler için bir değer tanımlamanın başka bir yolu vardır:

fonksiyon display(x = 5, y = 10)( let z = x * y; console.log(z); ) display(); // 50 gösterim(6); // 60 görüntü(6, 4) // 24

x ve y parametrelerine herhangi bir değer aktarılmazsa sırasıyla 5 ve 10 sayılarının değerleri olarak elde edilir. Bu yol, tanımsız ile karşılaştırmaktan daha özlü ve sezgiseldir.

Bu durumda, bir ifadeyi temsil eden parametrenin varsayılan değeri türetilebilir:

function display(x = 5, y = 10 + x)( let z = x * y; console.log(z); ) display(); // 75 görüntü(6); // 96 görüntü(6, 4) // 24

Bu durumda y parametresinin değeri x'in değerine bağlıdır.

Gerekirse, iletilen tüm parametreleri küresel olarak erişilebilir argümanlar dizisi aracılığıyla alabiliriz:

İşlev ekranı()( var z = 1; for(var i=0; i

Aynı zamanda, işlevi tanımlarken herhangi bir parametre belirtmemiş olmamızın bir önemi yok, yine de bunları iletebilir ve argümanlar dizisi aracılığıyla değerlerini alabiliriz.

Tanımsız parametre sayısı

Yayılma operatörünü kullanarak, bir parametre kullanılarak değişken sayıda değerin iletilebileceğini belirtebiliriz:

İşlev display(sezon, ...temps)( console.log(sezon); for(temps cinsinden indeks)( console.log(temps); ) ) display("Bahar", -2, -3, 4, 2, 5); display("Yaz", 20, 23, 31);

Bu durumda ikinci parametre...temps, bunun yerine değişken sayıda değerin geçilebileceğini belirtir. İşlevin kendisinde, temps aslında alabileceğimiz bir dizi geçirilen değeri temsil eder. Ancak buna rağmen fonksiyon çağrıldığında kendisine iletilen bir dizi değil, bireysel değerlerdir.

Konsol çıktısı:

Bahar -2 -3 4 2 5 Yaz 20 23 31

fonksiyon sonucu

Bir işlev bir sonuç döndürebilir. Bunun için return ifadesi kullanılır:

Değiş = 5; varz = kare(y); Document.write(y + " kare eşittir " + z); fonksiyon square(x) ( dönüş x * x; )

Geri dönüş ifadesini, yöntemden döndürülecek değer takip eder. Bu durumda, x'in karesidir.

Fonksiyonun sonucunu aldıktan sonra, onu başka bir değişkene atayabiliriz:

Varz = kare(y);

Parametre olarak işlevler

İşlevler, diğer işlevler için parametre görevi görebilir:

function sum(x, y)( x + y döndür; ) function subtract(x, y)( return x - y; ) function işlem(x, y, func)( var sonuç = func(x, y); konsol. log(sonuç); ) console.log("Toplam"); işlem(10, 6, toplam); // 16 console.log("Çıkar"); işlem(10, 6, çıkarma); // 4

İşlem işlevi üç parametre alır: x, y ve func. func - bir işlevi temsil eder ve işlemi tanımlarken ne tür bir işlev olacağı önemli değildir. Bilinen tek şey, func işlevinin iki parametre alıp tarayıcı konsolunda görüntülenen bir değer döndürmesidir. Bu nedenle, çeşitli işlevleri (bu durumda toplama ve çıkarma işlevleri gibi) tanımlayabilir ve bunları işlem işlevi çağrısına iletebiliriz.

Bir fonksiyondan bir fonksiyon döndürmek

Bir işlev başka bir işlevi döndürebilir:

fonksiyon menüsü(n)( if(n==1) dönüş fonksiyonu(x, y)( dönüş x+y;) else if(n==2) dönüş fonksiyonu(x, y)( dönüş x - y;) başka if(n==3) dönüş fonksiyonu(x, y)( dönüş x * y;) dönüş tanımsız; ) for(var i=1; i< 5; i++){ var action = menu(i); if(action!==undefined){ var result = action(5, 4); console.log(result); } }

Bu durumda, menü işlevi kendisine iletilen değere bağlı olarak üç işlevden birini veya tanımsız döndürür.

Makale geliştiriliyor!

Bir işlevin ne olduğunu ve onunla çalışmanın geleneksel (klasik) versiyonunu ele aldığımız bir makale. Ek olarak, işlevin argümanlarının (parametrelerinin) ve dönüş ifadesinin ne olduğunu analiz edeceğiz.

fonksiyon nedir?

Bir fonksiyon bazı komut seti, adlandırılabilir ve sonra ona bu isimle hitap et programın herhangi bir yerinden.

Fonksiyon kullanmanın klasik bir örneği. Web sayfası JavaScript kodu içerir, birkaç kez tekrarlandığı bazı parçalar. Bunu önlemek için şunları yapabilirsiniz: bu pasajı bir işlev olarak biçimlendir, A o zaman ara kodun doğru yerlerinde bu fonksiyonun adına göre. Bu işlevi çağırmak demek olacak talimatların yürütülmesi içinde yer almaktadır.

İşlevleri kullanarak JavaScript'te bazı görevlerin yürütülmesini nasıl organize edebilirim? Bunu yapmak için genellikle şöyle bir şey yaparsınız:

• görevi bileşen parçalarına (alt görevler) ayırın;
• alt görevler, işlevler aracılığıyla resmileştirilir;
• oluşturulan işlevlerin çağrısını kullanarak ana kodu geliştirin.

Sonuç olarak, böyle bir program daha yapılandırılmış hale gelir. Çeşitli değişiklikler yapmak ve yeni özellikler eklemek daha kolaydır.

Bir işlevi bildirme ve çağırma

JavaScript'teki işlev işlemleri 2 adıma ayrılabilir:

• duyuru (oluşturma) fonksiyonlar.
• çağrı (yürütme) bu fonksiyon

İşlev bildirimi. JavaScript'te bir işlev oluşturmak, function anahtar sözcüğünü, ardından işlevin adını ve ardından gerekirse parantez içinde x'i yazarak başlar. parametreler listelenir, ardından şu yönergeler gelir: süslü parantez içine alınmış.

// işlev bildirimi birİsim function birİsim() ( alert("birisi işlevini çağırdınız!"); ) JavaScript - İşlev Bildirimi Sözdizimi

JavaScript'te bu tür işlevlere denir işlev bildirimi bildirimi. JavaScript, bu türe ek olarak, işlevler arasında da ayrım yapar fonksiyon tanımı ifadesi ve ok işlevi ifadesi .

İşlev adının bileşimi, değişken adıyla aynı kuralları izler. Onlar. harf, rakam (0-9), "$" ve "_" işaretlerini içerebilir. Harf olarak sadece İngiliz alfabesindeki harflerin (a-z, A-Z) kullanılması tavsiye edilir. Değişken adı gibi bir işlev adı bir sayı ile başlayamaz.

Bir fonksiyon herhangi bir sayıda parametreye sahip olabilir veya hiç parametreye sahip olmayabilir. Parantezler her durumda dahil edilir. Birden fazla parametre varsa, birbirlerinden virgülle ayrılmaları gerekir. İşlev parametrelerine adlarıyla erişilir.

Komut seti, küme parantezleri içine alınmış, çağrıldığında yürütülecek olan işlev kodudur.

İşlev çağrısı. Bildirilen işlev kendi başına gerçekleştirilmeyecek. Çalıştırmak için çağrılması gerekir. Bir işlev, adı ve iki parantez belirtilerek çağrılır. Argümanlar gerekirse parantez içinde verilir.

// önceki örnekte verilen fonksiyonu çağırın birİsim(); JavaScript - İşlev Çağrısı Sözdizimi

JavaScript'teki bir işlev bir nesne midir?

JavaScript'teki işlevler nesnelerdir. JavaScript'teki her şey, altı ilkel veri türü dışında bir nesnedir. Ve eğer işlev bir nesneyse, o zaman ona yapılan bir başvuru bir değişkende saklanabilir.

// fonksiyon bildirimi birİsim function birİsim() ( alert("Birisim işlevini çağırdınız!"); ) var reference = birİsim;

Bundan sonra, işlevi şu şekilde çağırabilirsiniz:

Referans();

İşlev parametreleri ve bağımsız değişkenler

İşlev Argümanları işleve çağrı aşamasında iletilen değerlerdir. Bağımsız değişkenler birbirinden virgülle ayrılır.

// sayWelcome işlevini kendisine iletilen iki argümanla çağırmak sayWelcome("Ivan", "Ivanov"); // iki argümanlı sayWelcome işlevine bir çağrı daha sayWelcome("Peter", "Petrov");

fonksiyon parametreleri JavaScript'te bir işlev içindeki bağımsız değişkenlere atıfta bulunmanın bir yoludur. İşlev parametreleri, bildirim aşamasında parantez içinde açıklanmıştır.

Başka bir deyişle işlev parametreleri işlevi başlatma aşamasında otomatik olarak oluşturulan yerel değişkenlerdir. Değerler olarak, parametreler, çağrısı sırasında işleve iletilen karşılık gelen bağımsız değişkenleri alır. Parametrelere sadece bu fonksiyonun içinden erişebilirsiniz, onun dışında mevcut değillerdir.

// iki parametreye sahip sayWelcome işlevinin bildirimi function sayWelcome (userFirstName, userLastName) ( // "userFirstName" ve "userLastName" parametrelerinin değerlerini konsola görüntüleyen komut console.log("Welcome, " + userLastName + " " + userFirstName ); )

JavaScript'te, bir işlevi çağırırken bağımsız değişken sayısı parametre sayısı ile aynı olmak zorunda değildir. Çağrıldığında bir değere ayarlanmayan parametreler tanımsız olacaktır.

Örneğin yukarıdaki örnekten bir ve iki parametre belirtmeden fonksiyonu çağıralım:

// sayWelcome işlevini çağırmak ve ona bir bağımsız değişken iletmek sayWelcome("Peter"); // Hoşgeldin, tanımsız Peter // sayWelcome işlevini argüman iletmeden çağırmak sayWelcome(); // hoş geldiniz tanımsız tanımsız

Tarayıcı konsolunda kendisine iletilen bağımsız değişkenleri basitçe görüntüleyecek bir işlev örneği:

// işlev bildirimi function outputParam(param1, param2, param3) ( console.log(param1 + "; " + param2 + "; " + param3); ) // outputParam işlevini çağırır ve ona farklı sayıda parametre geçirerek outputParam(" Yağmur" ,"Kar","Sis"); // Yağmur; Kar; sis çıkışıParam(17); // 17; Tanımsız; tanımsız çıktıParam(24,33); // 24; 33; tanımsız outputParam(); // Tanımsız; Tanımsız; Tanımsız

Bir işlev içindeki argümanlara atıfta bulunmanın başka bir yolu, özel argümanlar nesnesini kullanmaktır. Bağımsız değişkenler yoluyla bağımsız değişkenlere erişim, normal bir dizinin öğeleriyle aynı şekilde gerçekleştirilir, örn. seri numaralarına göre. Böylece argüman - ilk argümanı, argümanlar - ikinci argümanı vb. almanızı sağlar.

// fonksiyon bildirimi toplam function sum(num1, num2) ( /* num1 veya argümanlar - 1 argümanın değerini al num2 veya argümanlar - 2 argümanın değerini al */ var toplam1 = sayı1 + sayı2, toplam2 = argümanlar + argümanlar; return "Toplam, yöntem 1 ile elde edilen toplam " + toplam1 + "; yöntem 2 ile elde edilen toplam " + toplam2; ) /* konsola toplam işlevinin sonucunu yazdır 7 - ilk argüman (olabilir hem num1 adıyla hem de bağımsız değişkenler kullanılarak erişilir) 4 - ikinci bağımsız değişken (hem num2 adıyla hem de bağımsız değişkenlerle erişilebilir) */ console.log(sum(7,4));

Bu yöntemler arasındaki temel fark, birincisinin yalnızca işlevi bildirme aşamasında adları verilen argümanlara atıfta bulunmanıza izin vermesidir. İkinci yöntem, bir adı olmasa bile (seri numarasına göre) herhangi bir bağımsız değişkenin değerini almanızı sağlar. JavaScript dilinin bu özelliği, evrensel esnek işlevler oluşturmanıza olanak tanır.

Argüman almanın yanı sıra, argümanlar nesnesi onların sayısını da bulmanızı sağlar. Bu, uzunluk özelliği kullanılarak yapılır.

Bağımsız değişkenler üzerinde yinelemeörneğin bir for veya for...of döngüsü kullanılarak bir işleve geçirilir.

// fonksiyonun bildirimi sum function sum() ( var i = 0; console.log("for döngüsünü kullanarak tüm bağımsız değişkenleri çıkar"); for (i; i< arguments.length; i++) { console.log(i + 1 + " аргумент равен " + arguments[i]); } console.log("Вывод всех аргументов с помощью цикла for...of"); for (arg of arguments) { console.log(arg); } } // вызов функции sum sum(7, 4, 3, 1);

Kendisine iletilen tüm bağımsız değişkenleri ve bunların sayısını konsola yazdıran bir işlev:

// fonksiyon bildirimi function myFunction () ( var i; console.log("Geçen parametre sayısı = " + argümanlar.uzunluk); // for döngüsünü kullanarak tüm parametreleri tekrarla for (i = 0; i)< arguments.length; i++) { console.log(i + " параметр = " + arguments[i]); } } // вызовы функции myFunction myFunction(3, 7, 27, "JavaScript"); myFunction(); myFunction("Яблоки", "Груши", "Апельсины");

Kendisine iletilen tüm bağımsız değişkenlerin toplamını gerçekleştiren bir işlev (sayıları önceden bilinmiyor):

// fonksiyon bildirimi var myCalc = function() ( // for döngüsünü kullanarak tüm parametreler üzerinde yineleme var i, sum = 0; for (i = 0; i lt; argümanlar.uzunluk; i++) ( toplam += argümanlar[i ] ; ) // toplamı sonuç olarak döndür toplamını döndür; ) // fonksiyon çağrısı (konsola çıktı) console.log(myCalc(4, 20, 17, -6));

Sonuç olarak, argümanlar nesnesi işlev gövdesinde uygulanabilir:

• geçirilen argüman sayısını kontrol etme;
• herhangi bir sayıda parametrenin işlenmesi.

İşlevin kendisine ek olarak, içindeki diğer işlevler de çağrı aşamasında kendisine iletilen bağımsız değişkenlere erişebilir.

function mainF(p1, p2) ( function childF() ( console.log("p1 = " + p1 + "; p2 = " + p2); ) childF(); ) mainF(3, 5); // p1 = 3; p2 = 5 anaF(4, 7); // p1 = 4; p2 = 7

Parametre varsayılan değeri

ECMAScript 2015'ten başlayarak (6) işlev parametresi varsayılan olarak sahip olacağı değeri ayarlayabilirsiniz.

Örneğin, "renk" parametresini varsayılan değeri olan "#009688" olarak ayarlayalım:

işlev setBGColor(color = "#009688") ( document.body.style.backgroundColor = color; ) setBGColor(); // arkaplan rengi #009688 setBGColor("red"); //arka plan rengi kırmızı olacak

ECMAScript 2015'ten önce, bir parametreyi varsayılan bir değere ayarlayabilirdiniz, örneğin şu şekildeydi:

işlev setBGColor(renk) ( color = color !== undefined ? color: "#009688"; // rengi varsayılan "#009688" değerine ayarla document.body.style.backgroundColor = color; )

Kalan parametreler

Bir işlevi çağırırken, ona sahip olduğundan daha fazla argüman iletirseniz, kalanları sözde kullanarak alabilirsiniz. kalan parametreler (geri kalan patametreler). Bu özellik dilde ECMAScript 2015'ten beri kullanılmaktadır.

// ...nums, bu durumda adla erişilebilen kalan parametrelerdir nums function doMath(mathAction, ...nums) ( var result = 0; nums.forEach(function(value) ( ​​​​switch () mathAction) ( case "sum": sonuç += değer; break; case "sumCube": sonuç += değer**3; break; case "sumSquare": sonuç += değer**2; break; varsayılan: sonuç = 0 ; ) ) ) sonucu döndür; ) console.log(doMath("toplam", 3, 4, 21, -4)); // 24 (3 + 4 + 21 + (-4)) console.log(doMath("sumSquare", 1, 4)); // 17 (1^2 + 4^2) console.log(doMath("sumCube", 3, 2, 4)); // 99 (3^3 + 2^3 + 4^3)

iade beyanı

Return deyimi, geçerli işlevin ifadesinin değerlendirilmesinin değerini veya sonucunu döndürmeyi amaçlar. Değer veya ifade, dönüşten bir boşlukla ayrılmalıdır. Ek olarak, return deyimi, işlevin yürütülmesini sonlandırır, örn. onu takip eden tüm talimatlar yürütülmeyecektir.

JavaScript'teki bir işlev, return ifadesinin kullanılıp kullanılmadığına bakılmaksızın her zaman bir sonuç döndürür.

// return function function sayWelcome (kullaniciAdisi, kullaniciSoyadi) ( if ((!kullaniciFirstName) || (!kullaniciSoyadi)) "Hosgeldiniz, anonim kullanici" döndürür; aksi takdirde "Hosgeldiniz, " + kullaniciSoyadi + " " + kullaniciAdi ; ) // değişken bildirimi kişi var kişi; // sayWelcome işlevinin sonucunu kişi değişkenine atayın person = sayWelcome("Ivan","Ivanov"); // değişkenin değerini konsola yazdırın console.log(person); //sayWelcome işlevinin sonucunu konsola gönderecek komut console.log(sayWelcome("Peter","Petrov")); //sayWelcome işlevinin sonucunu konsola gönderecek komut console.log(sayWelcome("Sidorov")); JavaScript - Parametre Doğrulamalı İşlev

JavaScript'teki bir işlev, return deyimi kullanılarak açıkça tanımlanmamış olsa bile her zaman yürütmesinin bir sonucu olarak bir sonuç döndürür. Bu sonuç tanımsızdır.

// 1. herhangi bir sonuç döndürmeyen bir işlev sayWelcome (userFirstName, userLastName) ( console.log("Welcome, " + userLastName + " " + userFirstName); ) // sonuç döndürmeyen bir işlevden sonuç almaya çalışın konsol .log(sayWelcome ("Ivan", "Ivanov")); // 2. değer işlevi olmayan bir dönüş ifadesi içeren işlev sayDay (day) ( day = "Bugün, " + gün; dönüş; //bu ifade, dönüş ifadesinden sonra geldiği için yürütülmeyecek console.log(day) ; ) // bir değer içermeyen dönüş ifadesini içeren işlevin sonucunu almaya çalışın console.log(sayDay("21 Şubat 2016")); JavaScript - Hiçbir şey döndürmeyen bir işlevden değer alın

return ifadesi için bir dönüş değeri belirtilmezse aynı sonuç elde edilir.

JavaScript'te işlev aşırı yüklemesi

Programlamada işlev aşırı yüklemesi, aynı kapsamda aynı ada sahip birden çok işlevi bildirme yeteneğidir. Bu tür işlevler, bağımsız değişkenlerin türüne ve sayısına göre birbirinden farklılık gösterir. Her fonksiyonun kendi programlama mantığı vardır. İşlev aşırı yüklemesi, aynı işlev adı kullanılarak benzer eylemlerin gerçekleştirilebilmesi için kullanılır.

JavaScript dili, örneğin C benzeri dillerde uygulanma biçiminde işlev aşırı yüklemesini desteklemez. Onlar. JavaScript'te, aynı kapsamda olan aynı ada sahip birden çok işlev oluşturamazsınız.

Benzer işlevsellik, aşağıdaki adımlar kullanılarak JavaScript'te uygulanabilir:

• Bir bağımsız değişkenin iletilip iletilmediğini kontrol etmek için, undefined değerini kontrol eden bir koşul kullanın.
• Bir işleve iletilen bağımsız değişken sayısını kontrol etmek için nesnenin arguments length özelliğini kullanın.
• Geçirilen bağımsız değişken değerinin türünü bulmak için typeof veya instanceof işleçlerini kullanın.
• Değişken sayıda bağımsız değişkenle çalışmak için arguments nesnesini kullanın.
• ECMAScript6 ile başlayarak, bağımsız değişkenler için varsayılan değerler belirleyebilirsiniz.

Örneğin, bir veya iki argümanla çağrılabilen bir fonksiyon oluşturalım:

//elementlerin arkaplan rengini değiştiren bir fonksiyon tanımlanıyor function setBgColor(bgColor,elements) ( // if (elements=== undefined) çağrılırken elements parametresi belirtilmemişse ( //sonra değerini "div" olarak ayarla) elements = "div "; ) // tüm öğeleri al elements = $(elements); // tüm öğeler arasında dolaş ve onları belirtilen arka plan rengine ayarla öğeleri.her(fonksiyon()( $(bu).css("arka plan) -color",bgColor) ; )); ) /*setBgColor fonksiyonunu bir parametre ile çağırın. Çünkü 2 parametresi belirtilmemişse, bu fonksiyon tüm div elemanlarının arka plan rengini değiştirir.*/ setBgColor("green"); /*setBgColor işlevini 2 parametre ile çağırın. Çünkü 2 parametresi ayarlandıysa, bu işlev yalnızca düğme öğelerinin arka plan rengini değiştirir.*/ setBgColor("#ff0000","button");

Yukarıdaki kodda bazı değişiklikler yapalım. Yani, ikinci parametre için varsayılan değeri belirtiyoruz:

//elementlerin arka plan rengini değiştiren bir fonksiyon bildiriyoruz // elements parametresi varsayılan olarak "div" olarak ayarlanmıştır function setBgColor(bgColor,elements = "div") ( //get all elements elements = $(elements); / /tüm öğeleri yineleyin ve belirtilen arka plan rengini onlara ayarlayın elements.each(function()( $(this).css("background-color",bgColor); )); ) //setBgColor işlevini bir parametre belirterek çağırın setBgColor("yeşil"); //2 parametre belirterek setBgColor işlevini çağırın setBgColor("#ff0000","button");

Bir kişinin günlük ihtiyaç duyduğu kalori sayısını hesaplayan JavaScript'te "aşırı yüklenmiş" bir işlevin nasıl uygulanacağına dair bir örnek:

// fonksiyon açıklaması function countCal(cinsiyet, boy) ( // parametreler: cinsiyet (cinsiyet) ve boy (boy) var sonuç; if ((cinsiyet === 0) || (cinsiyet === "erkek")) ( sonuç = (boy - 100) * 20; ) başka if ((cinsiyet === 1) || (cinsiyet === "kadın")) ( sonuç = (boy - 105) * 19; ) if (sonuç) ( // bağımsız değişkenler - etkinlik düzeyi if (bağımsız değişkenler) ( sonuç *= bağımsız değişkenler; ) console.log("Normal yaşam için kalori sayısı: " + sonuç); ) else ( console.log("Geçersiz parametreler"); ) ) / * fonksiyonun çağrılması ve geçirilmesi 2 argüman (1 - "man", sex ve argümanlar adıyla erişilebilir; 2 - 185 değeri, sex ve argümanlar adıyla erişilebilir) */ countCal("man", 185); /* fonksiyonun çağrılması ve 3 parametre iletilmesi, fonksiyon açıklamasında sadece 2 bulunmasına rağmen (bu durumda, 3 parametrenin değerini sadece argüman olarak alabilirsiniz) */ countCal(0, 185, 2);

özyineleme

Özyineleme, bazı işlevlerin gövdesi içinde kendisine yapılan bir çağrıdır.

Bir işlev çağrısı, genellikle adıyla veya bu işleve referans içeren bir değişken aracılığıyla bildirilme biçimine bağlı olarak yapılır.

function fact(n) ( if (n === 1) ( return 1; ) return fact(n-1) * n; ) console.log(gerçek(5)); // 120

Bir işlevi gövdesi içinde yalnızca adıyla değil, ayrıca arguments nesnesinin callee özelliğini kullanarak da çağırabilirsiniz. Ancak bu özelliği kullanmamak daha iyidir, çünkü. modası geçmiş. Bunun dışında katı modda hiç çalışmıyor.

Yerleşik (standart) işlevler nelerdir?

JavaScript'in çok sayıda yerleşik (standart) işlevi vardır. Bu işlevler zaten tarayıcı motorunun kendisinde açıklanmıştır. Hemen hemen hepsi, bir veya başka bir nesnenin yöntemleridir.

Örneğin, yerleşik işlev (yöntem) uyarısını çağırmak için önceden bildirilmesi gerekmez. Tarayıcıda zaten açıklanmıştır. Alert yöntemi, bir ad, parantezler ve içlerinde bir bağımsız değişken belirtilerek çağrılır. Bu yöntem, ekranda bir iletişim kutusu biçiminde bir mesaj görüntülemek için tasarlanmıştır. Metin mesajı, bu fonksiyonun parametre değerinden alınır.

// fonksiyonu çağırın alert alert("Bazı metin"); JavaScript - Uyarı işlevini çağırma

Yerleşik bir işlev, çağrıldığında gerçekleştirebileceği tüm eylemleri açıklar. Yerleşik işlevlerin eylemlerinin açıklaması programlayıcıdan gizlenir. Bu tür eylemlere bir örnek, matematiksel bir ifadenin hesaplanması ve sonucun döndürülmesi veya bir html belgesinin içeriğinin değiştirilmesidir. Bir işlev, bir tür eylem gerçekleştirdiği parametreleri veya bağımsız değişkenleri alabilir. Bağımsız değişkenler , veya olabilir.

İşlev çağrısı şu şekilde yapılır:

var a = işlevAdı(par1, par2, …, parN);

js, matematiksel ifadeleri hesaplamak için birçok yerleşik işleve sahiptir. Örneğin, Math.sin işlevi açının sinüsünü döndürür (açı radyan olarak verilir), Math.sqrt işlevi kendisine parametre olarak iletilen sayının karekökünü hesaplar vb.

Örneğin, 256'nın karekökünü hesaplayalım.

var b = Math.sqrt(256);

Yukarıdaki iki örnekten birinin kodunu çalıştırdıktan sonra, b değişkeni 16 değerini içerecektir.

Bugün, betiklerinizin bir şekilde bazı bilgileri dış dünyaya iletmesine izin verecek iki işleve de bakacağız. Bunları gerçek projeler yazarken kullanmanız pek olası değildir, ancak öğrenmenize yardımcı olurlar.

uyarı işlevi

Bu işlev, bir OK düğmesiyle donuk gri bir kutuda görüntüleyecek bir değerin metin gösterimini parametre olarak alır. Kullanıcı bu düğmeyi tıklatana kadar komut dosyasının yürütülmesi devam etmeyecektir.

belge.yazma işlevi

Bu işlev, kendisine parametre olarak iletilen değerin metinsel temsilini html belgesine yazar. Ne yaptığınızı tam olarak bilmiyorsanız, gerçek projeler için senaryo yazarken asla bu yöntemi kullanmayın. Sayfa yüklendikten sonra bu işlevi çağırırsanız, büyük olasılıkla bu işleve yapılan son çağrının görüntülendiği metni içeren boş bir sayfa göreceksiniz.

Matematik Nesnesi

Bu nesne, matematiksel ifadeleri ve bazı sabitleri hesaplamak için işlevler içerir. Nesneler hakkında daha sonra konuşacağız. Math nesnesini kullanmak için, sadece özelliklerine (fonksiyonlar ve sabitler) erişmenin Math.FunctionNameOrConstantName yazılması gerektiğini hatırlamanız gerekir.

Math nesnesinin içerdiği özellikler ("Math" sözcüğü çıkarılmıştır):

1. Sabitler

2.718281828459045
LN10 2,302585092994046 (günlük doğal 10)
LN2 0,6931471805599453 (doğal 2 logaritma)
LOG10E 0,4342944819032518 (ondalık logaritma e)
LOG2E 1.4426950408889634 (e'nin 2 tabanlı logaritması)
PI 3.141592653589793
SQRT1_2 0,7071067811865476 (0,5'in karekökü)
SQRT2 1,4142135623730951 (ikinin karekökü)

2. Trigonometrik fonksiyonlar

günah - sinüs
kosinüs - kosinüs
tanjant - teğet

Bu fonksiyonların bağımsız değişken olarak aldığı açı, derece olarak değil, radyan olarak verilir. Bir açı değerini dereceden radyana dönüştürmek için Math.PI ile çarpın ve 180'e bölün. Tersine, bir açıyı radyandan dereceye dönüştürmek için 180 ile çarpın ve Math.PI'ye bölün.

Yani 60 derece π/3 radyan, 30 derece π/6 radyan ve 45 derece π/4 radyandır.

3. Ters trigonometrik fonksiyonlar

acos - sayının ark kosinüsü yani. kosinüsü bağımsız değişkene eşit olan açı (radyan cinsinden)
asin - sayının arksinüsü yani sinüsü bağımsız değişkene eşit olan bir açı (radyan cinsinden)
atan - sayının ark teğeti, yani teğeti bağımsız değişkene eşit olan açı (radyan cinsinden)
atan2 - iki bağımsız değişkenin bölümünün yay tanjantı

3. Diğer işlevler

abs - sayı modülü
kat - sayının tamsayı kısmı, "kat" veya aşağı yuvarlama. Örneğin Math.floor(-0.9) ve Math.floor(-0.1) değerlerinin -1 olduğunu, sıfır olmadığını unutmayın.
tavan - yuvarlama veya "tavan"
exp - e x ifadesinin değerini döndürür; burada x, işlev bağımsız değişkenidir
log - bir sayının doğal logaritmasını döndürür
pow - iki argüman alır ve tabanı birinci argüman ve üssü ikinci olan kuvveti döndürür.
max - rasgele sayıda parametre kabul eder ve bunların maksimumunu döndürür
min - rasgele sayıda parametre kabul eder ve bunların minimumunu döndürür
random - 0 ile 1 arasında rastgele bir değer döndürür
yuvarlak - bir sayıyı birimlere yuvarlar
sqrt - bir sayının karekökünü hesaplar

Sonraki derslerde diğer birçok yerleşik işlevi ele alacağız, ancak bugünlük bu kadar.

Bir işlevi çağırmanın beş yolu

• JavaScript

• Tercüme

Hataların JavaScript'teki işlevlerin nasıl çalıştığının yanlış anlaşılmasından kaynaklandığı JavaScript koduyla sık sık karşılaşıyorum (bu arada, bu kodun çoğu benim tarafımdan yazılmıştır). JavaScript çok paradigmalı bir dildir ve fonksiyonel programlama için mekanizmalara sahiptir. Bu olasılıkları keşfetme zamanı. Bu makalede, size JavaScript'te işlevleri çağırmanın beş yolunu göstereceğim.

JavaScript öğrenmenin ilk aşamalarında, yeni başlayanlar genellikle içindeki işlevlerin, örneğin C# ile aynı şekilde çalıştığını düşünürler. Ancak JavaScript'te işlev çağırma mekanizmalarının bir dizi önemli farkı vardır ve bunların göz ardı edilmesi, bulunması kolay olmayacak hatalara neden olabilir.

Üç öğeden oluşan bir dizi döndüren basit bir işlev yazalım - geçerli this değeri ve işleve iletilen iki argüman.
işlev makeArray(arg1, arg2)( [ this, arg1, arg2 ]; ) döndür

En yaygın yol: küresel çağrı

JavaScript'te, komut dosyasının bir tarayıcıda mı yoksa başka bir ortamda mı çalıştığı önemli değildir, her zaman tanımlanır küresel nesne. Betiğimizde herhangi bir şeye "iliştirilmemiş" (yani, bir nesne bildiriminin dışında) herhangi bir kod aslında genel bir nesne bağlamındadır. Bizim durumumuzda, makeArray sadece kendi başına çalışan bir fonksiyon değildir. Aslında makeArray, global nesnenin (tarayıcıda kod yürütülmesi durumunda) window yöntemidir. Bunu kanıtlamak çok kolay:
alert(pencere türü.methodThatDoesntExist); // => undefined alert(typeof window.makeArray); // => fonksiyon
Yani, makeArray("bir", "iki"); window.makeArray("one", "two"); işlevini çağırmakla eşdeğerdir. .

İşlevleri çağırmanın en yaygın yolunun bu olması beni üzüyor, çünkü bu küresel bir işlevi ima ediyor. Ve hepimiz biliyoruz ki global fonksiyonlar ve değişkenler programlamanın en iyi şekli değildir. Bu özellikle JavaScript için geçerlidir. Küresel tanımlardan kaçının, pişman olmayacaksınız.

İşlev çağrısı kuralı #1:İşlev, bir nesne belirtilmeden doğrudan çağrılırsa (örneğin, myFunction()), bunun değeri global nesne olacaktır (tarayıcıda kod yürütme durumunda pencere).

Yöntem çağrısı

Genel olarak bu basit ilkenin anlaşılmaması, genellikle olay işlemede hatalara yol açar:

İlk düğmeye tıklamak mesajı gösterecektir btn1, çünkü bu durumda işlevi bir yöntem olarak çağırıyoruz ve bu, işlevin içinde bu yöntemin ait olduğu nesnenin değerini alacaktır. İkinci butona tıkladığınızda görüntülenecektir. pencere, çünkü bu durumda doğrudan buttonClicked'ı çağırıyoruz (yani obj.buttonClicked() gibi değil). Üçüncü düğme durumunda olduğu gibi, öğe etiketine bir olay işleyicisi atadığımızda da aynı şey olur. Üçüncü butona tıklamak, ikinci ile aynı mesajı gösterecektir.

jQuery gibi kütüphaneleri kullanırken, bunun hakkında düşünmenize gerek yok. jQuery, this değerinin olayı tetikleyen öğe olması için olay işleyicisindeki this değerini yeniden yazmaya özen gösterir:
// jQuery kullanın $("#btn1").click(function() ( alert(this.id); // jQuery, "bunun" bir düğme olduğundan emin olur ));
JQuery bunun değerini değiştirmeyi nasıl başarıyor? Alttarafı oku.

İki yol daha: Apply() ve call()

İşlev çağrısı kuralı #3:İşlevi başka bir nesneye kopyalamadan bunun değerini geçersiz kılmak istiyorsanız, myFunction.apply(obj) veya myFunction.call(obj) kullanabilirsiniz.

İnşaatçılar

Aksi takdirde, yapıcının içindeki kod büyük olasılıkla başka bir dilde yazacağınız koda benzer olacaktır. Bu durumda bunun değeri, oluşturduğunuz yeni nesnedir.

İşlev çağrısı kuralı #4: new operatörüyle bir işlev çağrıldığında, bunun değeri, JavaScript çalışma zamanı tarafından oluşturulan yeni bir nesne olacaktır. Bu işlev açıkça herhangi bir nesne döndürmezse, bu dolaylı olarak döndürülür.

Çözüm

İnsanlar bilgisayar biliminin dahiler için bir sanat olduğunu düşünüyor. Gerçekte bunun tersi doğrudur - sadece birçok insan sanki küçük çakıl taşlarından bir duvar oluşturuyormuş gibi birbirinin üzerinde duran şeyler yapar.

Donald Knuth

alert gibi işlev çağrılarını zaten gördünüz. İşlevler, JavaScript programlamanın ekmeği ve yağıdır. Bir programın bir parçasını sarmak ve onu bir değişken olarak adlandırmak fikri çok popüler. Büyük programları yapılandırmak, tekrarı azaltmak, alt programlara isim atamak ve alt programları birbirinden izole etmek için bir araçtır.

İşlevlerin en belirgin kullanımı yeni bir sözlük oluşturmaktır. Sıradan insan nesri için kelimeler bulmak kötü bir biçimdir. Bir programlama dilinde bu gereklidir.

Ortalama bir yetişkin Rusça konuşan kişi yaklaşık 10.000 kelime biliyor. Nadir bir programlama dili, 10.000 yerleşik komut içerir. Ve bir programlama dilinin kelime dağarcığı daha net bir şekilde tanımlanmıştır, bu nedenle insan dilinden daha az esnektir. Bu nedenle, gereksiz tekrardan kaçınmak için genellikle kendi sözlerimizi eklemek zorunda kalırız.

fonksiyon tanımı

var square = function(x) ( dönüş x * x; ); console.log(kare(12)); // → 144

Bir işlev, function anahtar sözcüğüyle başlayan bir ifade tarafından oluşturulur. İşlevlerin bir dizi parametresi (bu durumda yalnızca x) ve işlev çağrıldığında yürütülecek talimatları içeren bir gövdesi vardır. Bir fonksiyonun gövdesi, tek bir ifadeden oluşsa bile her zaman kaşlı ayraçlar içine alınır.

Bir fonksiyonun birkaç parametresi olabilir veya hiç olmayabilir. Aşağıdaki örnekte, makeNoise bir parametre listesine sahip değilken, power iki taneye sahiptir:

Var makeNoise = function() ( console.log("Siktir!"); ); ses yap(); // → Saçmalık! var güç = fonksiyon(taban, üs) ( var sonuç = 1; for (var sayımı = 0; sayımı)< exponent; count++) result *= base; return result; }; console.log(power(2, 10)); // → 1024

Güç ve kare gibi bazı işlevler bir değer döndürürken, yalnızca bir yan etkisi olan makeNoise gibi diğerleri döndürmez. return deyimi, işlev tarafından döndürülen değeri tanımlar. Program işleme bu yönergeye ulaştığında, hemen işlevden çıkar ve bu değeri, işlevin çağrıldığı koddaki yere geri döndürür. ifade olmadan dönüş, tanımsız döndürür.

Parametreler ve kapsam

İşlevlerin önemli bir özelliği, bir işlev içinde oluşturulan değişkenlerin (parametreler dahil) o işlev içinde yerel olmasıdır. Bu, güç örneğinde, işlev her çağrıldığında sonuç değişkeninin oluşturulacağı ve bunun ayrı ayrı enkarnasyonlarının hiçbir şekilde birbiriyle ilişkili olmadığı anlamına gelir.

Değişkenlerin bu konumu yalnızca işlevler içinde oluşturulan parametreler ve değişkenler için geçerlidir. Herhangi bir fonksiyonun dışında ayarlanan değişkenler, program boyunca görünür olduklarından global değişkenler olarak adlandırılır. Aynı ada sahip bir yerel değişken bildirmediyseniz, bu tür değişkenlere bir işlev içinde de erişebilirsiniz.

Aşağıdaki kod bunu göstermektedir. x'e bir değer atayan iki işlevi tanımlar ve çağırır. İlki onu yerel olarak ilan eder, böylece yalnızca yerel değişkeni değiştirir. İkincisi beyan etmez, bu nedenle fonksiyonun içinde x ile çalışmak, örneğin başında ayarlanan global x değişkenini ifade eder.

var x = "dış"; var f1 = function() ( var x = "f1'in içinde"; ); f1(); konsol günlüğü(x); // → var f2'nin dışında = function() ( x = "f2'nin içinde"; ); f2(); konsol günlüğü(x); // → f2 içinde

Bu davranış, işlevler arasında yanlışlıkla etkileşimi önlemeye yardımcı olur. Programın herhangi bir yerinde tüm değişkenler kullanılmış olsaydı, bir değişkenin farklı amaçlar için kullanılmadığından emin olmak çok zor olurdu. Ve bir değişkeni yeniden kullanırsanız, üçüncü taraf kodunun değişkeninizin değerleriyle karıştığı garip etkilerle karşılaşırsınız. İşlev-yerel değişkenlerini yalnızca işlev içinde var olacak şekilde ele alan dil, işlevlerle ayrı küçük evrenlermiş gibi çalışmayı mümkün kılar, bu da bir bütün olarak kodun tamamı hakkında endişelenmemenizi sağlar.

İç içe kapsamlar

Örneğin, aşağıdaki oldukça anlamsız işlev, içinde iki tane daha içerir:

var manzara = işlev() ( var sonuç = ""; var düz = işlev(boyut) ( için (var sayısı = 0; sayısı)< size; count++) result += "_"; }; var mountain = function(size) { result += "/"; for (var count = 0; count < size; count++) result += """; result += "\\"; }; flat(3); mountain(4); flat(6); mountain(1); flat(1); return result; }; console.log(landscape()); // → ___/""""\______/"\_

Düz ve dağ fonksiyonları, tanımlandığı fonksiyonun içinde oldukları için sonuç değişkenini görürler. Ancak birbirlerinin sayım değişkenlerini göremezler çünkü bir fonksiyonun değişkenleri diğerinin kapsamı dışındadır. Ve peyzaj fonksiyonunun dışındaki ortam, bu fonksiyonun içinde tanımlanan değişkenlerin hiçbirini görmez.

Kısacası, her yerel kapsamda, onu içeren tüm kapsamları görebilirsiniz. Bir işlevin içinde bulunan değişkenler kümesi, bu işlevin programda bildirildiği yere göre belirlenir. Ana programda en üst seviyede tanımlananlar da dahil olmak üzere, fonksiyon tanımını çevreleyen bloklardaki tüm değişkenler görünür durumdadır. Kapsamlara yönelik bu yaklaşıma sözcüksel denir.

Diğer programlama dillerini çalışmış kişiler, kaşlı ayraçlar içindeki herhangi bir bloğun kendi yerel ortamını yarattığını düşünebilir. Ancak JavaScript'te yalnızca işlevler kapsam oluşturur. Bağımsız blokları kullanabilirsiniz:

var bir şey = 1; ( var bir şey = 2; // Bir şey değişkeniyle bir şey yap... ) // Bloktan çık...

Ancak bloğun içindeki bir şey, dışarıdakiyle aynı değişkendir. Bu tür bloklara izin verilse de, bunları yalnızca if ifadeleri ve döngüler için kullanmak mantıklıdır.

Bu sana garip geliyorsa, sadece sana öyle gelmiyor. JavaScript 1.7, var gibi çalışan ancak yalnızca işlev için değil, herhangi bir blok için yerel olan değişkenler oluşturan let anahtar sözcüğünü tanıttı.

Değer olarak işlevler

Ama bunlar iki farklı şey. Bir işlev çağrısı, basit bir değişken gibi kullanılabilir - örneğin, herhangi bir ifadede kullanılabilirler. Bir işlev çağrısını yeni bir değişkende saklamak, başka bir işleve parametre olarak geçirmek vb. mümkündür. Ayrıca, işlev çağrısını saklayan değişken sıradan bir değişken olarak kalır ve değeri değiştirilebilir:

Var launchMissiles = function(value) ( ​​​​füzeSystem.start("lütfen!"); ); if (safeMode) launchMissiles = function(value) (/* release */);

5. Bölümde, işlev çağrılarını diğer işlevlere ileterek yapılabilecek harika şeyleri tartışacağız.

işlev bildirimi

fonksiyon square(x) ( dönüş x * x; )

Bu bir işlev bildirimidir. İfade, kare değişkenini tanımlar ve ona verilen işlevi atar. Şimdiye kadar her şey yolunda. Böyle bir tanımda tek bir tuzak vardır.

Console.log("Gelecek diyor ki:", gelecek()); function future() ( "HALA uçan arabamız yok."; )

Bu kod, işlev onu kullanan kodun altında bildirilse bile çalışır. Bunun nedeni, işlev bildirimlerinin, programların yukarıdan aşağıya normal yürütülmesinin bir parçası olmamasıdır. Kapsamlarının en üstüne "hareket ederler" ve o kapsamdaki herhangi bir kod tarafından çağrılabilirler. Bu bazen kullanışlıdır, çünkü yukarıdaki tüm işlevleri kullanıldıkları yerde tanımlama endişesi duymadan kodu en anlamlı sırada yazabilirsiniz.

Ancak, koşullu bir blok veya döngü içine bir işlev bildirimi yerleştirirsek ne olur? Bunu yapmak zorunda değilsin. Tarihsel olarak, JavaScript'i çalıştırmak için farklı platformlar bu tür durumları farklı şekilde ele aldı ve mevcut dil standardı bunu yasaklıyor. Programlarınızın tutarlı bir şekilde çalışmasını istiyorsanız, işlev bildirimlerini yalnızca diğer işlevler veya ana program içinde kullanın.

Örnek işlev() ( function a() () // Normule if (bir şey) ( function b() () // Ay-yy-yy! ) )

çağrı yığını

greet(kim) ( console.log("Merhaba, " + kim); ) greet("Semyon"); console.log("Pokeda");

Şuna benzer bir şekilde işlenir: selamlamanın çağrılması geçişin işlevin başına atlamasına neden olur. Kontrolü ele alan, işini yapan ve kontrolü geri veren yerleşik console.log işlevini çağırır. Sonra selâmın sonuna varır ve çağrıldığı yere döner. Sonraki satır tekrar console.log'u çağırır.

Şematik olarak, bu aşağıdaki gibi gösterilebilir:

Baştan selamlar console.log selamlar üst konsol.log üst

İşlevin çağrıldığı yere geri dönmesi gerektiğinden, bilgisayarın işlevin çağrıldığı bağlamı hatırlaması gerekir. Bir durumda, console.log tekrar merhaba olarak değişmelidir. Diğerinde programın sonuna geri döner.

Bilgisayarın içeriği hatırladığı yere yığın denir. İşlev her çağrıldığında, geçerli içerik yığının üstüne itilir. İşlev geri döndüğünde, yığından en üstteki içeriği çıkarır ve devam etmek için onu kullanır.

Yığın depolama, bellek alanı gerektirir. Yığın çok büyüdüğünde, bilgisayar çalışmayı durdurur ve "yığın taşması" veya "çok fazla özyineleme" gibi bir şey verir. Aşağıdaki kod bunu gösteriyor - bilgisayara iki işlev arasında sonsuz sıçramalara yol açan çok karmaşık bir soru soruyor. Daha doğrusu, bilgisayar sonsuz bir yığına sahip olsaydı, sonsuz sıçramalar olurdu. Gerçekte, yığın taşar.

tavuk() işlevi ( yumurta döndür(); ) işlev yumurta() ( dönüş tavuk(); ) console.log(tavuk() + " önce geldi."); // → ??

İsteğe Bağlı Argümanlar

Alert("Merhaba", "İyi akşamlar", "Herkese merhaba!");

Resmi olarak, işlev bir bağımsız değişken alır. Ancak bu şekilde meydan okunduğunda şikayet etmez. Geri kalan bağımsız değişkenleri yok sayar ve "Merhaba" gösterir.

JavaScript, bir işleve iletilen bağımsız değişkenlerin sayısı konusunda çok hoşgörülüdür. Çok fazla geçerseniz, fazla olanlar dikkate alınmayacaktır. Çok az - eksik olanlara undefined değeri atanacak.

Bu yaklaşımın dezavantajı, işleve yanlış sayıda bağımsız değişken iletmenin mümkün ve hatta muhtemel olmasıdır ve hiç kimse size bundan şikayet etmeyecektir.

Bunun tersi, isteğe bağlı bağımsız değişkenleri alan işlevler oluşturabilmenizdir. Örneğin, güç işlevinin bir sonraki sürümünde, hem iki hem de bir bağımsız değişkenle çağrılabilir - ikinci durumda, üs ikiye eşit olacaktır ve işlev bir kare gibi çalışır.

fonksiyon gücü(taban, üs) ( if (üs == tanımsız) üs = 2; var sonuç = 1; for (var saymak = 0; saymak)< exponent; count++) result *= base; return result; } console.log(power(4)); // → 16 console.log(power(4, 3)); // → 64

Bir sonraki bölümde, bir fonksiyonun gövdesinin kendisine iletilen argümanların tam sayısını size nasıl söyleyebileceğini göreceğiz. Bu kullanışlı çünkü herhangi bir sayıda bağımsız değişken alan bir işlev oluşturmanıza olanak tanır. Örneğin, console.log bu özelliği kullanır ve kendisine iletilen tüm bağımsız değişkenleri yazdırır:

Console.log("R", 2, "D", 2); // → R 2 D 2

kapanışlar

Aşağıdaki örnek bu sorunu göstermektedir. Yerel bir değişken oluşturan wrapValue işlevini bildirir. Ardından, bu yerel değişkeni okuyan ve değerini döndüren bir işlev döndürür.

function wrapValue(n) ( var localVariable = n; return function() ( return localVariable; ); ) var wrap1 = wrapValue(1); var sarma2 = sarmaDeğeri(2); konsol günlüğü(wrap1()); // → 1 console.log(wrap2()); // → 2

Bu geçerlidir ve olması gerektiği gibi çalışır - değişkene erişim kalır. Ayrıca, aynı değişkenin birden çok örneği aynı anda var olabilir, bu da yerel değişkenlerin her işlev çağrısıyla yeniden yaratıldığı gerçeğini daha da doğrular.

Yerel bir değişkenin bazı örneklerine referansla çalışabilme becerisine kapatma denir. Yerel değişkenleri kapatan bir işleve kapatma işlevi denir. Sizi yalnızca değişken ömürler hakkında endişelenmekten kurtarmakla kalmaz, aynı zamanda işlevleri yaratıcı bir şekilde kullanmanıza olanak tanır.

Ufak bir değişiklikle örneğimizi herhangi bir sayı ile sayıları çarpan bir fonksiyona dönüştürüyoruz.

fonksiyon çarpanı(faktör) ( dönüş fonksiyonu(sayı) ( dönüş numarası * çarpan; ); ) var iki kez = çarpan(2); console.log(iki kez(5)); // → 10

Artık wrapValue örneğinden localVariable gibi ayrı bir değişkene gerek yoktur. Parametrenin kendisi yerel bir değişken olduğu için.

Böyle düşünmeye başlamak pratik gerektirir. Zihinsel modelin iyi bir versiyonu, fonksiyonun kodu gövdesinde dondurup bir pakete sardığını hayal etmektir. Geri dönüş işlevini(...) (...) gördüğünüzde, bunu daha sonra kullanmak üzere dondurulmuş bir kod parçası için bir kontrol paneli olarak düşünün.

Örneğimizde çarpan, iki kez değişkeninde sakladığımız donmuş bir kod parçasını döndürür. Son satır, kaydedilen kodu (dönüş numarası * faktör;) etkinleştiren değişkende bulunan işlevi çağırır. Çarpan çağrıldığında tanımlanan faktör değişkenine hala erişimi vardır ve ayrıca çözme (5) sırasında sayısal bir parametre olarak iletilen bağımsız değişkene erişimi vardır.

özyineleme

fonksiyon güç(taban, üs) ( if (üs == 0) 1 döndürür; aksi takdirde taban * güç(taban, üs - 1); ) console.log(güç(2, 3)); // → 8

Matematikçiler üssü bu şekilde tanımlar ve belki de bu, kavramı bir döngüden daha zarif bir şekilde tanımlar. İşlev, çoklu çarpma elde etmek için kendisini birçok kez farklı bağımsız değişkenlerle çağırır.

Ancak bu uygulamanın bir sorunu var - normal bir JavaScript ortamında, döngülü sürümden 10 kat daha yavaş. Döngü, bir işlevi çağırmaktan daha ucuzdur.

Hıza karşı zarafet ikilemi oldukça ilginç. İnsan rahatlığı ile makine rahatlığı arasında belirli bir boşluk vardır. Herhangi bir program daha büyük ve daha karmaşık hale getirilerek hızlandırılabilir. Programcının doğru dengeyi bulması gerekir.

İlk üs alma durumunda, zarif olmayan döngü oldukça basit ve anlaşılırdır. Özyineleme ile değiştirmek mantıklı değil. Bununla birlikte, genellikle programlar o kadar karmaşık kavramlarla çalışır ki, okunabilirliği artırarak verimliliği azaltmak istenir.

Birçok kez tekrarlanan ve tamamen katıldığım temel kural - programın yavaşladığından emin olana kadar performans konusunda endişelenmeyin. Eğer öyleyse, en uzun süre dayanan parçaları bulun ve burada verimlilik için zarafetle ticaret yapın.

Tabii ki, performansı hemen tamamen göz ardı etmemeliyiz. Çoğu durumda, üs almada olduğu gibi, zarif çözümlerden çok fazla basitlik elde edemeyiz. Bazen deneyimli bir programcı, basit bir yaklaşımın asla yeterince hızlı olmayacağını hemen anlar.

Bunu gündeme getirdim çünkü çok sayıda acemi programcı küçük şeylerde bile verimliliğe sarılır. Sonuç daha büyük, daha karmaşık ve çoğu zaman hatasız değil. Bu tür programların yazılması daha uzun sürer ve genellikle çok daha hızlı çalışmazlar.

Ancak özyineleme her zaman döngülere göre daha az verimli bir alternatif değildir. Bazı problemlerin özyineleme ile çözülmesi daha kolaydır. Çoğu zaman, bu, her biri dallanabilen birkaç ağaç dalının geçişidir.

İşte size bir bilmece: 1 rakamından başlayarak ve sonra 5 ekleyerek veya 3 ile çarparak sonsuz sayıda sayı elde edebilirsiniz. Bir sayı verildiğinde, böyle bir dizi bulmaya çalışan bir işlevi nasıl yazarız? Belirli bir sayıya götüren toplamalar ve çarpmalar? Örneğin 13 sayısı, önce 1 ile 3'ü çarptıktan sonra iki kez 5 ekleyerek elde edilebilir. Ve 15 sayısını bu şekilde elde etmek genellikle imkansızdır.

Özyinelemeli çözüm:

function findSolution(target) ( function find(start, history) ( if (start == hedef) geçmişi döndürür; else if (start > target) null döndürür; aksi takdirde find(start + 5, "(" + history + " + 5)") || find(başlangıç ​​* 3, "(" + tarih + " * 3)"); ) dönüş bul(1, "1"); ) console.log(findSolution(24)); // → (((1 * 3) + 5) * 3)

Bu örnek mutlaka en kısa çözümü bulmaz - herhangi birini tatmin eder. Programın nasıl çalıştığını hemen anlamanızı beklemiyorum. Ama yinelemeli düşünme konusundaki bu harika alıştırmanın temeline inelim.

Dahili işlev bulma özyinelemelidir. İki bağımsız değişken alır - geçerli sayı ve bu sayıya nasıl ulaştığımızın kaydını içeren bir dize. Ve adım dizimizi gösteren bir dize veya null döndürür.

Bunu yapmak için, işlev üç eylemden birini gerçekleştirir. Verilen sayı hedefe eşitse, o zaman mevcut geçmiş ona ulaşmanın tam yoludur, bu yüzden döndürülür. Verilen sayı hedeflenenden büyükse çarpma ve toplamaya devam etmenin bir anlamı yoktur, çünkü bu şekilde sadece artacaktır. Ve henüz hedefe ulaşmadıysak, işlev verilen sayıdan başlayarak her iki olası yolu da dener. Her yolla bir kez olmak üzere kendini iki kez çağırır. İlk arama null değil döndürürse, döndürür. Aksi takdirde ikincisi iade edilir.

Fonksiyonun istenen etkiyi nasıl elde ettiğini daha iyi anlamak için, 13 sayısı için bir çözüm arayışı içinde gerçekleşen çağrılarına bakalım.

Bul(1, "1") bul(6, "(1 + 5)") bul(11, "(1 + 5) + 5)") bul(16, "(((1 + 5) + 5) ) + 5)") çok büyük bul(33, "(((1 + 5) + 5) * 3)") çok büyük bul(18, "((1 + 5) * 3)") çok büyük bul( 3, "(1 * 3)") find(8, "(1 * 3) + 5)") find(13, "(((1 * 3) + 5) + 5)") bulundu!

Girinti, çağrı yığınının derinliğini gösterir. Bul işlevi ilk kez (1 + 5) ve (1 * 3) ile başlayan çözümleri kontrol etmek için kendisini iki kez çağırır. İlk çağrı (1 + 5) ile başlayan bir çözüm arar ve istenen sayıdan küçük veya ona eşit bir sayı veren tüm çözümleri kontrol etmek için özyinelemeyi kullanır. Bulamıyor ve null döndürüyor. Ardından operatör || ve seçeneği inceleyen bir işlev çağrısına atlar (1 * 3). Burada şanslıyız, çünkü üçüncü özyinelemeli aramada 13 elde ederiz. Bu arama bir dizi döndürür ve || yol boyunca bu dizeyi yukarıya geçirir ve sonuç olarak çözümü döndürür.

Büyütme İşlevleri

İlk olarak, benzer kodu birden çok kez yazarsınız. Bundan kaçınılmalıdır - daha fazla kod, hatalar için daha fazla alan ve programı anlamaya çalışanlar için daha fazla okuma materyali anlamına gelir. Bu yüzden yinelenen işlevselliği alıyoruz, ona iyi bir ad veriyoruz ve onu bir işleve koyuyoruz.

İkinci yol, ayrı bir işleve yerleştirilmeye değer bazı yeni işlevlere ihtiyaç olduğunu keşfetmenizdir. İşlevin adıyla başlarsınız ve ardından gövdesini yazarsınız. Hatta işlevin kendisi tanımlanmadan önce işlevi kullanan kodu yazarak başlayabilirsiniz.

Bir işlevi adlandırmanın sizin için ne kadar zor olduğu, onun işlevselliğini ne kadar iyi anladığınızı gösterir. Bir örnek alalım. Çiftlikteki inek ve tavuk sayısını ve ardından "inekler" ve "tavuklar" kelimelerini takip eden iki sayı yazdıran bir program yazmamız gerekiyor. Öndeki sayılara sıfır eklemeniz gerekir, böylece her biri tam olarak üç konum işgal eder.

007 İnekler 011 Tavuklar

Açıkçası, iki argümanlı bir fonksiyona ihtiyacımız var. Kodlamaya başlayalım.
// printFarmInventory işlevi printFarmInventory(inekler, tavuklar) ( var cowString = String(inekler); while (inekString.uzunluk)< 3) cowString = "0" + cowString; console.log(cowString + " Коров"); var chickenString = String(chickens); while (chickenString.length < 3) chickenString = "0" + chickenString; console.log(chickenString + " Куриц"); } printFarmInventory(7, 11);

Bir dizgeye .length eklersek uzunluğunu elde ederiz. Görünüşe göre while döngüleri, 3 karakterlik bir dizi elde edene kadar sayılara baştaki sıfırları ekler.

Hazır! Ancak kodu çiftçiye göndermek üzereyken (elbette ağır bir çekle birlikte) bizi arar ve bize çiftlikte domuzları olduğunu söyler ve domuz sayısı çıktısını ekleyebilir miyiz? programa mı?

Tabii ki mümkün. Ancak bu dört satırdan kodu kopyalayıp yapıştırmaya başladığımızda durup düşünmemiz gerektiğini anlıyoruz. Daha iyi bir yol olmalı. Programı geliştirmeye çalışıyoruz:

// outputZeroPaddedWithLabel işlevi printZeroPaddedWithLabel(sayı, etiket) ( var numberString = String(sayı); while (numberString.length< 3) numberString = "0" + numberString; console.log(numberString + " " + label); } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { printZeroPaddedWithLabel(cows, "Коров"); printZeroPaddedWithLabel(chickens, "Куриц"); printZeroPaddedWithLabel(pigs, "Свиней"); } printFarmInventory(7, 11, 3);

İşler! Ancak printZeroPaddedWithLabel adı biraz garip. Üç şeyi - çıktı, sıfır doldurma ve bir etiket - tek bir işlevde birleştirir. Yinelenen parçanın tamamını bir işleve doldurmak yerine, bir kavramı vurgulayalım:

// Sıfırlar işlevini ekle zeroPad(sayı, genişlik) ( var string = String(number); while (string.length< width) string = "0" + string; return string; } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { console.log(zeroPad(cows, 3) + " Коров"); console.log(zeroPad(chickens, 3) + " Куриц"); console.log(zeroPad(pigs, 3) + " Свиней"); } printFarmInventory(7, 16, 3);

Güzel, açıklayıcı adı zeroPad olan bir işlev, kodun anlaşılmasını kolaylaştırır. Ve sadece bizim durumumuzda değil, birçok durumda kullanılabilir. Örneğin, sayılarla biçimlendirilmiş tabloları görüntülemek için.

İşlevler ne kadar akıllı ve çok yönlü olmalıdır? Bir sayıyı üç konuma kadar sıfırlarla dolduran basit bir işlevin yanı sıra kesirleri, negatif sayıları, nokta hizalamayı, farklı karakterlerle doldurmayı vb. destekleyen sayıları biçimlendirmek için süslü bir genel amaçlı işlev yazabiliriz.

İyi bir kural, yalnızca kesinlikle ihtiyacınız olan işlevselliği eklemektir. Bazen her küçük ihtiyaç için genel amaçlı çerçeveler oluşturmak cazip gelebilir. Ona diren. İşi asla bitiremeyeceksiniz, sadece kimsenin kullanmayacağı bir sürü kod yazın.

Fonksiyonlar ve Yan Etkiler

Grup örneğindeki ilk yardımcı işlev olan printZeroPaddedWithLabel, bir dize yazdırmanın yan etkisi nedeniyle çağrılır. İkincisi, zeroPad, dönüş değeri nedeniyle. Ve ikinci özelliğin birincisinden daha sık işe yaraması tesadüf değil. Değer döndüren işlevlerin birbiriyle birleştirilmesi, yan etki oluşturan işlevlere göre daha kolaydır.

Saf işlev, yalnızca hiçbir yan etkisi olmayan değil, aynı zamanda kodun geri kalanının yan etkilerine de bağlı olmayan özel bir tür değer döndüren işlevdir - örneğin, yanlışlıkla değiştirilebilen genel değişkenlerle çalışmaz başka bir yer. Saf bir işlev, aynı bağımsız değişkenlerle çağrıldığında aynı sonucu verir (ve başka hiçbir şey yapmaz) - ki bu oldukça güzel. Onunla çalışmak çok kolay. Böyle bir işlevin çağrısı, kodun anlamını değiştirmeden zihinsel olarak çalışmasının sonucuyla değiştirilebilir. Böyle bir işlevi test etmek istediğinizde, onu çağırabilir ve bu bağlamda çalışırsa herhangi bir şekilde çalışacağından emin olabilirsiniz. Çok saf olmayan işlevler, birçok faktöre bağlı olarak farklı sonuçlar verebilir ve test edilmesi ve açıklanması zor yan etkileri olabilir.

Bununla birlikte, tam olarak temiz olmayan işlevler yazmaktan çekinmemeli veya bu tür işlevlerden kutsal bir kod temizliği başlatmamalısınız. Yan etkiler genellikle yardımcı olur. console.log işlevinin saf bir sürümünü yazmanın bir yolu yoktur ve bu işlev oldukça kullanışlıdır. Bazı operasyonları yan etkilerle ifade etmek daha kolaydır.

Sonuç

İşlevleri anlamanın anahtarı yerel kapsamlardır. Bir işlev içinde bildirilen parametreler ve değişkenler, işlevde yereldir, her çağrıldığında yeniden oluşturulur ve dışarıdan görünmez. Başka bir işlevin içinde bildirilen işlevlerin kapsamına erişimi vardır.

Program tarafından gerçekleştirilen farklı görevleri işlevlere bölmek çok yararlıdır. Kendinizi tekrarlamak zorunda değilsiniz, işlevler kodu anlamsal parçalara ayırarak daha okunabilir hale getirir, tıpkı bir kitabın bölümlerinin ve bölümlerinin düz metni düzenlemeye yardımcı olması gibi.

Egzersizler

Asgari

Console.log(dk(0, 10)); // → 0 console.log(min(0, -10)); // → -10

özyineleme

Sıfır çifttir.
Birim tuhaftır.
Herhangi bir N sayısı, N-2 ile aynı pariteye sahiptir.

Bu kurallara göre özyinelemeli bir isEven işlevi yazın. Bir sayı almalı ve bir boole değeri döndürmelidir.

50 ve 75'te test edin. -1 vermeyi deneyin. Neden böyle davranıyor? Bir şekilde düzeltmek mümkün mü?

50 ve 75'te test edin. -1'de nasıl davrandığına bakın. Neden? Bunu düzeltmenin bir yolunu düşünebilir misin?

Console.log(isEven(50)); // → true console.log(isEven(75)); // → false console.log(isEven(-1)); // → ??

Fasulyeleri sayıyoruz.

Bir dizgenin N karakter sayısı, bir dizgenin uzunluğunu .length ile almaya benzer şekilde, .charAt(N)("string".charAt(5)) eklenerek elde edilebilir. Dönüş değeri, tek karakterli bir dize olacaktır (örneğin, "k"). Dizinin ilk karakterinin konumu 0'dır, bu da son karakterin dize.uzunluk - 1 konumuna sahip olacağı anlamına gelir. Diğer bir deyişle, iki karakterlik bir dizenin uzunluğu 2'dir ve karakter konumları 0 ve 1 olacaktır.

Bir diziyi bağımsız değişken olarak alan ve dizideki "B" karakterlerinin sayısını döndüren bir countBs işlevi yazın.

Ardından, biraz countB'ler gibi çalışan bir countChar işlevi yazın, tek farkı ikinci bir parametre almasıdır, yani dizede arayacağımız karakter ("B" karakterlerinin sayısını saymak yerine). Bunu yapmak için, countBs işlevini yeniden yazın.