Funksiyalar

Kopincha skriptning kop joylarida oxshash harakatni bajarishga togri keladi.

Masalan, tashrif buyuruvchi tizimga kirganida, chiqganida va boshqa joylarda chiroyli korinishdagi xabarni korsatish kerak.

Funksiyalar dasturning asosiy "qurilish bloklari"dir. Ular kodni takrorlanmasdan kop marta chaqirishga imkon beradi.

Biz allaqachon ornatilgan funksiyalar misollarini kordik, masalan alert(message), prompt(message, default) va confirm(question). Lekin biz oz funksiyalarimizni ham yaratishimiz mumkin.

Funksiya eloni

Funksiya yaratish uchun funksiya elonidan foydalanishimiz mumkin.

U quyidagicha korinadi:

function showMessage() {
  alert("Hammaga salom!");
}

function kalit sozi birinchi orinda turadi, keyin funksiya nomi, songra qavslar orasida parametrlar royxati (vergul bilan ajratilgan, yuqoridagi misolda bosh, keyinroq misollarni koramiz) va nihoyat jingalak qavslar orasida funksiya kodi, funksiya tanasi deb ham ataladi.

function name(parameter1, parameter2, ...parameterN) {
  // tana
}

Bizning yangi funksiyamizni nomi bilan chaqirish mumkin: showMessage().

Masalan:

function showMessage() {
  alert( 'Hammaga salom!' );
}

showMessage();
showMessage();

showMessage() chaqiruvi funksiya kodini bajaradi. Bu yerda xabarni ikki marta koramiz.

Bu misol funksiyalarning asosiy maqsadlaridan birini aniq korsatadi: kod takrorlanishini oldini olish.

Agar xabar yoki uni korsatish usulini ozgartirishga hojat tugilsa, kodni faqat bir joyda ozgartirish kifoya: uni chiqaradigan funksiyada.

Mahalliy ozgaruvchilar

Funksiya ichida elon qilingan ozgaruvchi faqat osha funksiya ichida korinadi.

Masalan:

function showMessage() {
  let message = "Salom, men JavaScript!"; // mahalliy o'zgaruvchi

  alert( message );
}

showMessage(); // Salom, men JavaScript!

alert( message ); // <-- Xato! O'zgaruvchi funksiyaga mahalliy

Tashqi ozgaruvchilar

Funksiya tashqi ozgaruvchiga ham kirishi mumkin, masalan:

let userName = 'John';

function showMessage() {
  let message = 'Salom, ' + userName;
  alert(message);
}

showMessage(); // Salom, John

Funksiya tashqi ozgaruvchiga toliq kirish huquqiga ega. U uni ozgartirishi ham mumkin.

Masalan:

let userName = 'John';

function showMessage() {
  userName = "Bob"; // (1) tashqi o'zgaruvchini o'zgartirdi

  let message = 'Salom, ' + userName;
  alert(message);
}

alert( userName ); // John funksiya chaqiruvidan oldin

showMessage();

alert( userName ); // Bob, qiymat funksiya tomonidan o'zgartirildi

Tashqi ozgaruvchi faqat mahalliy yoq bolgan taqdirda ishlatiladi.

Agar bir xil nomli ozgaruvchi funksiya ichida elon qilinsa, u tashqi ozgaruvchini soyaga oladi. Masalan, quyidagi kodda funksiya mahalliy userName dan foydalanadi. Tashqi ozgaruvchi etiborga olinmaydi:

let userName = 'John';

function showMessage() {
  let userName = "Bob"; // mahalliy o'zgaruvchi e'lon qilish

  let message = 'Salom, ' + userName; // Bob
  alert(message);
}

// funksiya o'zining userName ini yaratadi va ishlatadi
showMessage();

alert( userName ); // John, o'zgarmagan, funksiya tashqi o'zgaruvchiga kirmagan

Parametrlar

Parametrlar yordamida funksiyalarga ixtiyoriy malumotlarni uzata olamiz.

Quyidagi misolda funksiyaning ikkita parametri bor: from va text.

function showMessage(from, text) { // parametrlar: from, text
  alert(from + ': ' + text);
}

showMessage('Ann', 'Salom!'); // Ann: Salom! (*)
showMessage('Ann', "Qandaysiz?"); // Ann: Qandaysiz? (**)

Funksiya (*) va (**) qatorlarida chaqirilganda, berilgan qiymatlar mahalliy ozgaruvchilar from va text ga nusxalanadi. Keyin funksiya ulardan foydalanadi.

Mana yana bir misol: bizda from ozgaruvchisi bor va uni funksiyaga uzatamiz. Etibor bering: funksiya from ni ozgartiradi, lekin ozgarish tashqarida korinmaydi, chunki funksiya har doim qiymatning nusxasini oladi:

function showMessage(from, text) {

  from = '*' + from + '*'; // "from" ni chiroyliroq qilish

  alert( from + ': ' + text );
}

let from = "Ann";

showMessage(from, "Salom"); // *Ann*: Salom

// "from" qiymati bir xil, funksiya mahalliy nusxani o'zgartirdi
alert( from ); // Ann

Qiymat funksiya parametri sifatida uzatilganda, u argument deb ham ataladi.

Boshqacha qilib aytganda, bu atamalarni togri qoyish uchun:

• Parametr funksiya elonidagi qavslar ichida korsatilgan ozgaruvchi (bu elon vaqtidagi atama).
• Argument funksiya chaqirilganda uzatiladigan qiymat (bu chaqiruv vaqtidagi atama).

Biz funksiyalarni parametrlarini korsatib elon qilamiz, keyin argumentlarni uzatib chaqiramiz.

Yuqoridagi misolda shunday deyish mumkin: showMessage funksiyasi ikkita parametr bilan elon qilingan, keyin ikkita argument bilan chaqirilgan: from va "Salom".

Standart qiymatlar

Agar funksiya chaqirilsa, lekin argument berilmasa, tegishli qiymat undefined boladi.

Masalan, yuqorida aytib otilgan showMessage(from, text) funksiyasini bitta argument bilan chaqirish mumkin:

showMessage("Ann");

Bu xato emas. Bunday chaqiruv "*Ann*: undefined" ni chiqaradi. text qiymati uzatilmagani uchun u undefined boladi.

Funksiya elonida = yordamida parametr uchun standart (tashlab qoyilsa ishlatish uchun) qiymatni belgilashimiz mumkin:

function showMessage(from, text = "matn berilmagan") {
  alert( from + ": " + text );
}

showMessage("Ann"); // Ann: matn berilmagan

Endi agar text parametri uzatilmasa, u "matn berilmagan" qiymatini oladi.

Parametr mavjud bolsa ham, lekin qatiy ravishda undefined ga teng bolsa ham standart qiymat ishlaydi:

showMessage("Ann", undefined); // Ann: matn berilmagan

Bu yerda "matn berilmagan" satr, lekin u yanada murakkab ifoda bolishi mumkin, u faqat parametr yoqolgan taqdirda baholanadi va tayinlanadi. Demak, bu ham mumkin:

function showMessage(from, text = anotherFunction()) {
  // anotherFunction() faqat text berilmaganida bajariladi
  // uning natijasi text qiymati bo'ladi
}

function showMessage(from, text) {
  if (text === undefined) {
    text = 'matn berilmagan';
  }

  alert( from + ": " + text );
}

function showMessage(from, text) {
  // Agar text qiymati yolg'on bo'lsa, standart qiymatni tayinlash
  // bu text == "" ni umuman matn yo'qligi bilan bir xil deb hisoblaydi
  text = text || 'matn berilmagan';
  ...
}

Muqobil standart parametrlar

Bazan funksiya elonidan keyin keyinroq parametrlar uchun standart qiymatlarni tayinlash mantiqan togri keladi.

Funksiya bajarilishi davomida parametrning uzatilganligini undefined bilan solishtirib tekshirishimiz mumkin:

function showMessage(text) {
  // ...

  if (text === undefined) { // agar parametr yo'qolgan bo'lsa
    text = 'bo\'sh xabar';
  }

  alert(text);
}

showMessage(); // bo'sh xabar

Yoki || operatoridan foydalanishimiz mumkin:

function showMessage(text) {
  // agar text undefined yoki boshqa yolg'on bo'lsa, uni 'bo'sh'ga o'rnatish
  text = text || 'bo\'sh';
  ...
}

Zamonaviy JavaScript dvigatellari nullish coalescing operator ?? ni qollab-quvvatlaydi, bu 0 kabi kopchilik yolgon qiymatlar normal deb hisoblanishi kerak bolganda yaxshiroqdir:

function showCount(count) {
  // agar count undefined yoki null bo'lsa, "noma'lum"ni ko'rsatish
  alert(count ?? "noma'lum");
}

showCount(0); // 0
showCount(null); // noma'lum
showCount(); // noma'lum

Qiymat qaytarish

Funksiya natija sifatida chaqiruvchi kodga qiymat qaytarishi mumkin.

Eng oddiy misol ikkita qiymatni qoshadigan funksiya:

function sum(a, b) {
  return a + b;
}

let result = sum(1, 2);
alert( result ); // 3

return direktivasi funksiyaning istalgan joyida bolishi mumkin. Bajarilish unga yetganda, funksiya toxtaydi va qiymat chaqiruvchi kodga qaytariladi (yuqorida result ga tayinlangan).

Bitta funksiyada return ning koplab holatlari bolishi mumkin. Masalan:

function checkAge(age) {
  if (age >= 18) {
    return true;
  } else {
    return confirm('Ota-onangizdan ruxsat bormikan?');
  }
}

let age = prompt('Yoshingiz nechada?', 18);

if ( checkAge(age) ) {
  alert( 'Ruxsat berildi' );
} else {
  alert( 'Ruxsat rad etildi' );
}

return ni qiymat bolmagan holda ishlatish mumkin. Bu funksiyaning darhol chiqishiga sabab boladi.

Masalan:

function showMovie(age) {
  if ( !checkAge(age) ) {
    return;
  }

  alert( "Sizga filmni ko'rsatamiz" ); // (*)
  // ...
}

Yuqoridagi kodda, agar checkAge(age) false qaytarsa, showMovie alert ga otmaydi.

function doNothing() {
  /* bo'sh */
}

alert(doNothing() === undefined); // true

function doNothing() {
  return;
}

alert(doNothing() === undefined); // true

return
 (some + long + expression + or + whatever * f(a) + f(b))

return;
 (some + long + expression + or + whatever * f(a) + f(b))

return (
  some + long + expression
  + or +
  whatever * f(a) + f(b)
  )

Funksiyani nomlash

Funksiyalar harakatlardir. Shuning uchun ularning nomi odatda fel boladi. U qisqa, imkon qadar aniq va funksiya nima qilishini tasvirlab berishi kerak, shunda kodni oqiyotgan kishi funksiya nima qilishini tushunadi.

Harakat haqida taxminan tasvirlaydigan fel prefiksi bilan funksiyani boshlash keng tarqalgan amaliyotdir. Jamoada prefikslar manosi haqida kelishuv bolishi kerak.

Masalan, "show" bilan boshlanadigan funksiyalar odatda biror narsani korsatadi.

Funksiya boshlangan

• "get" qiymat qaytaradi,
• "calc" biror narsani hisoblaydi,
• "create" biror narsa yaratadi,
• "check" biror narsani tekshiradi va boolean qaytaradi, va hokazo.

Bunday nomlar misollari:

showMessage(..)     // xabar ko'rsatadi
getAge(..)          // yoshni qaytaradi (qandaydir usul bilan oladi)
calcSum(..)         // yig'indini hisoblaydi va natijani qaytaradi
createForm(..)      // forma yaratadi (va odatda uni qaytaradi)
checkPermission(..) // ruxsatni tekshiradi, true/false qaytaradi

Prefikslar ornida, funksiya nomiga bir nazar tashlash uning qanday ish qilishini va qanday qiymat qaytarishini tushunishga imkon beradi.

Funksiyalar == Sharhlar

Funksiyalar qisqa va aynan bitta ishni qilishi kerak. Agar bu ish katta bolsa, funksiyani bir nechta kichikroq funksiyalarga bolish arziydi. Bazan bu qoidaga amal qilish oson bolmasligi mumkin, lekin bu albatta yaxshi narsa.

Alohida funksiya nafaqat sinovdan otkazish va disk raskadka qilish osonroq uning mavjudligi ozi ajoyib sharh!

Masalan, quyidagi ikkita showPrimes(n) funksiyasini solishtiring. Har biri n gacha tub sonlarni chiqaradi.

Birinchi variant yorliq ishlatadi:

function showPrimes(n) {
  nextPrime: for (let i = 2; i < n; i++) {
    for (let j = 2; j < i; j++) {
      if (i % j == 0) continue nextPrime;
    }

    alert(i); // tub son
  }
}

Ikkinchi variant tublikni tekshirish uchun qoshimcha isPrime(n) funksiyasidan foydalanadi:

function showPrimes(n) {

  for (let i = 2; i < n; i++) {
    if (!isPrime(i)) continue;

    alert(i);  // tub son
  }
}

function isPrime(n) {
  for (let i = 2; i < n; i++) {
    if ( n % i == 0) return false;
  }
  return true;
}

Ikkinchi variant tushunish osonroq, shunday emasmi? Kod qismi orniga biz harakat nomini koramiz (isPrime). Bazan odamlar bunday kodni oz-ozini tavsiflovchi deb atashadi.

Shunday qilib, funksiyalarni qayta ishlatishni niyat qilmasak ham yaratish mumkin. Ular kodni strukturalashtiradi va oqishga qulay qiladi.

Xulosa

Funksiya eloni quyidagicha korinadi:

function name(vergul, bilan, ajratilgan, parametrlar) {
  /* kod */
}

• Funksiyaga parametr sifatida uzatilgan qiymatlar uning mahalliy ozgaruvchilariga nusxalanadi.
• Funksiya tashqi ozgaruvchilarga kirishi mumkin. Lekin u faqat ichkaridan tashqariga ishlaydi. Funksiyadan tashqaridagi kod uning mahalliy ozgaruvchilarini kormaydi.
• Funksiya qiymat qaytarishi mumkin. Agar qaytarmasa, uning natijasi undefined boladi.

Kodni toza va tushunish oson qilish uchun funksiyada asosan mahalliy ozgaruvchilar va parametrlardan foydalanish tavsiya etiladi, tashqi ozgaruvchilardan emas.

Parametrlar oladigan, ular bilan ishlaydigan va natija qaytaradigan funksiyani tushunish har doim parametr olmaydigan, lekin yon tasir sifatida tashqi ozgaruvchilarni ozgartiradigan funksiyadan osondir.

Funksiyani nomlash:

• Nom funksiya nima qilishini aniq tasvirlashi kerak. Kodda funksiya chaqiruvini korganimizda, yaxshi nom bizga u nima qilishi va qaytarishini darhol tushuntirib beradi.
• Funksiya harakat, shuning uchun funksiya nomlari odatda feldir.
• create, show, get, check va boshqa koplab taniqli funksiya prefikslari mavjud. Funksiya nima qilishini bildirish uchun ulardan foydalaning.

Funksiyalar skriptlarning asosiy qurilish bloklaridir. Endi biz asoslarni korib chiqdik, shuning uchun aslida ularni yaratish va ishlatishni boshlashimiz mumkin. Lekin bu yolning faqat boshlanishi. Biz ularga kop marta qaytamiz va ularning ilgor xususiyatlarini chuqurroq organamiz.