გამეორება: ფუნქციები

ეს იმ მასალის შეფასებაა, რომელიც განვიხილეთ ფუნქციების ამ სახელმძღვანელოში.

როდესაც ვწერთ პროგრამებს, ჩვენ ხშირად გვსურს, შეგვეძლოს კოდის რაღაც ნაწილის ახლიდან გაშვება ამ ნაწილის მთლიანად ხელახლა დაწერის გარეშე. ჩვენ ვსაჭიროებთ კოდის დაჯგუფებისა და დასახელების გზას და შემდეგ ამ კოდის მისი სახელითვე გამოძახების საშუალებას. ამას ეწოდება ფუნქცია.

იმისათვის, რომ ფუნქცია შევქმნათ, ჩვენ ჯერ უნდა გამოვაცხადოთ ის და მივანიჭოთ სახელი (ზუსტად ისე, როგორც ცვლადს ვქმნით), შემდეგ კი შევუდგეთ ფუნქციის განსაზღვრას:

var sayHello = function() {
};

ფუნქციის შიგნით ნებისმიერი სახის კოდის განთავსებაა შესაძლებელი - ერთი ან რამდენიმე დებულების - რაც დამოკიდებულია იმაზე, თუ რისი გაკეთება გსურთ. ამ ფუნქციაში ჩვენ უბრალოდ შემთხვევით ადგილას გამოგვყავს შეტყობინება:

var sayHello = function() {
   text("Halllllllo!", random(200), random(200));
};

თუ ჩვენ უბრალოდ გამოვაცხადებთ ფუნქციას, არაფერი მოხდება. იმისათვის, რომ პროგრამამ კოდი შეასრულოს, ჩვენ უნდა „გამოვიძახოთ" ეს ფუნქცია. ამისათვის უნდა დავწეროთ მისი სახელი ცარიელ ფრჩხილებთან ერთად:

sayHello();

და შემდეგ ჩვენ შეგვიძლია, გამოვიძახოთ ის სურვილისამებრ, იმდენჯერ, რამნდენჯერაც მოგვინდება!

sayHello();
sayHello();
sayHello();

ჩვენ ხშირად გვსურს ფუნქციების შეცვლა და გაუმჯობესება იმისათვის, რომ ვუთხრათ პროგრამას: „მოკლედ, შეასრულე მთელი ეს კოდი, უბრალოდ შეასრულე ოდნავ სხვანაირად." ეს მიდგომა ხდის კოდს შესაფერისს განმეორებითი გამოყენებისთვის და უფრო მოქნილს. ამ შედეგის მიღწევა შესაძლებელია, თუ განვსაზღვრავთ ფუნქციის „არგუმენტებს", გამოვიყენებთ ამ არგუმენტებს ფუნქციის მოქმედების პრინციპის შესაცვლელად და ფუნქციის გამოძახების დროს გადავცემთ ამ არგუმენტებს.

მაგალითად, რა უნდა ვქნათ, როცა გვინდა შეტყობინების გამოჩენის ადგილის განსაზღვრა, ზუსტად ისე, როგორც გვინდა ხოლმე rect()-ებისა და elipse()-ების დახატვის ადგილის მითითება? წარმოვიდგინოთ, რომ არსებობს ისეთი გზა, რომელიც მოგვცემდა შეტყობინების განთავსების ადგილის ორი ზუსტი კოორდინატის მითითების საშუალებას:

sayHello(50, 100);
sayHello(150, 200);

იმისათვის რომ ეს ავამუშავოთ, ჩვენ უნდა შევცვალოთ sayHello ფუნქციის განსაზღვრება ისე, რომ ის იღებდეს 2 არგუმენტს, შემდეგ კი იყენებდეს საკუთარი კოდის ფარგლებში:

var sayHello = function(xPos, yPos) {
   text("Halllllllo!", xPos, yPos);
};

არგუმენტები, რომლებსაც გადასცემთ, ემსგავსებიან ცვლადებს თქვენი ფუნქციის განსაზღვრებაში და მათი სახელი დამოკიდებულია იმაზე, თუ რას დაარქმევთ მათ ფრჩხილებში. ჩვენ შეგვიძლია, მარტივად შევუმოკლოთ მათ სახელები:

var sayHello = function(x, y) {
   text("Halllllllo!", x, y);
};

ჩვენს ფუნქციებს შეუძლია, მიიღოს არგუმენტების განუსაზღვრელი რაოდენობა - ნული, ერთი, ორი ან მეტი. ჩვენ ასევე შეგვიძლია, უბრალოდ შევცვალოთ ჩვენი ფუნქცია ისე, რომ ის იღებდეს სახელს, რომელსაც ის გამოიყენებს მისალმებისას:

var sayHello = function(name) {
   text("Halllllllo, " + name, random(200), random(200));
};

ჩვენ ასევე შეგვიძლია დავარქვათ მას ეს:

sayHello("Winston");
sayHello("Pamela");

ჩვენ შეგვიძლია, გავაერთიანოთ ეს იდეები და მივაღებინოთ მას სამი არგუმენტი სახელისთვის და ადგილმდებარეობისთვის:

var sayHello = function(name, x, y) {
   text("Halllllllo " + name, x, y);
};

და შემდეგ დავარქვათ მას ეს:

sayHello("Winston", 10, 100);

ყველაფერი დამოკიდებულია იმაზე, თუ რა გსურთ, რომ გააკეთოს ფუნქციამ და რამდენად გსურთ მისი შესაძლებლობების შეცვლა. ყოველთვის შეგიძლიათ, დაიწყოთ არგუმენტების გარეშე და დაამატოთ ისინი პროცესში, საჭიროების მიხედვით.

ამდენ ხანს თქვენ სწორედ რომ ფუნქციებს იყენებდით! ზუსტად მათი დახმარებით თქვენ ქმნიდით ნახატებსა და ანიმაციებს, როგორებიცაა rect, ellipse, triangle და ა. შ.. ყველა ეს ფუნქცია შემოდის ProcessingJS ბიბლიოთეკიდან და ჩვენ ვტვირთავთ მათ ყოველ პროგრამაში, რომელსაც აქ ქმნით, რათა მუდამ შეგეძლოთ მათი გამოყენება. ჩვენ განვსაზღვრეთ ფუქნციები თქვენთვის, რადგან გვეგონა, რომ ისინი გამოგადგებათ და ახლა არჩევანი თქვენზეა: რომელი ახალი ფუნქციის გამოყენება გსურთ თქვენს საკუთარ პროგრამებში. მაგალითდ, ჩვენ გაწვდით ellipse ფუქნციას, თუმცა არ გაწვდით cat ფუქნციას - თუ თქვენი პროგრამა შეიცავს ბევრ cat-ს სხვადასხვა ადგილას, ჯობს, შექმნათ თქვენი საკუთარი cat ფუნქცია!

არსებობს კიდევ ერთი მძლავრი რამ, რაც შეგიძლიათ, გააკეთოთ ფუქნციების საშუალებით - ჩვენ შეგვიძლია, მივაღებინოთ მათ სხვადასხვა მნიშვნელობები, გამოვათვლეინოთ ისინი და დავაბრუნებინოთ ახალი მნიშვნელობა. წარმოიდგინეთ ყველაფერი, რაც შეგიძლიათ, გააკეთოთ კალკულატორით - შეკრიბოთ მნიშვნელობები, გამოაკლოთ, გამოითვალოთ კვადრატული ფესვი, გაამრავლოთ და ა. შ.. ამ ყველაფრის გაკეთება შესაძლებელია ფუნქციების საშუალებით, რომლებიც იღებენ მონაცემებს და აბრუნებენ შედეგს. ფუნქციები იღებენ მონაცემებს არგუმენტების სახით და აბრუნებენ შედეგს return დებულების საშუალებით. იხილეთ ფუნქცია, რომელიც კრებს ორ რიცხვს და აბრუნებს შედეგს:

var addNumbers = function(num1, num2) {
  var result = num1 + num2;
  return result;
};

var sum = addNumbers(5, 2);
text(sum, 200, 200); // აჩვენებს "7"-ს

return დებულება აკეთებს ორ რამეს: უბრუნებს მნიშვნელობას იმას, ვინც ის გამოიძახა (ზუსტად ამიტომ შევძელით მისი შენახვა sum ცვლადში) და იმთავითვე გამოდის ფუნქციიდან. ეს ყველაფერი იმას ნიშნავს, რომ სისულელე იქნებოდა ასეთი რამის დაწერა, რადგან კოდის ბოლო ხაზი არასდროს შესრულდება:

var addNumbers = function(num1, num2) {
  var result = num1 + num2;
  return result;
  result = result * 2; // სისულელე!
};

ფუნქციები დაბრუნებადი მნიშვნელობებით საკმაოდ გამოსადეგია პროგრამებში მონაცემებთან სამუშაოდ და შეგვიძლია, გავაერთიანოთ ისინი გამოსახულებების მისაღებადაც:

var biggerSum = addNumbers(2, 5) + addNumbers(3, 2);

თქვენ შეგიძლიათ, გამოიძახოთ ფუნქციები ფუნქციების გამოძახების შიგნით, თუმცა ზოგჯერ ეს რთული წასაკითხი ხდება:

var hugeSum = addNumbers(addNumbers(5, 2), addNumbers(3, 7));

ახლა, როდესაც უკვე იცით ფუნქციების შექმნა, რომლებშიც მოათავსებთ კოდის ბლოკებს, ჩვენ შემოგვაქვს მნიშვნელოვანი კონცეფცია: ლოკალური ცვლადები და გლობალური ცვლადები.

როდესაც ვსაზღვრავთ ახალ ცვლადს ფუნქციის შიგნით, ჩვენ ვამბობთ, რომ ეს ცვლადი ლოკალურია ფუქნციასთან მიმართებაში. ამას იმიტომ ვამბობთ, რომ მხოლოდ ფუნქციას შეუძლია, დაინახოს ცვლადი - პროგრამის დანარჩენი ნაწილი ამას ვერ ახერხებს. როგორც კი ვხვდებით ფუნქციის გარეთ, შეგვიძლია, მივიჩნიოთ, რომ ეს ცვლადი აღარ არსებობს. შემდეგ ფუქნციაში localResult ლოკალური ცვლადია:

var addNumbers = function(num1, num2) {
  var localResult = num1 + num2;
  println("The local result is: " + localResult);
  return localResult;
};
addNumbers(5, 7);
println(localResult); // ოჰ, არა!

როდესაც ამ კოდს ვუშვებთ, ვიღებთ შეცდომას ბოლო ხაზზე: "localResult is not defined." ჩვენ განვსაზღვრეთ ცვლადი მხოლოდ ფუნქციის შიგნით var localResult = ხაზით და ის არ არის განსაზღვრული ფუნქციის გარეთ.

როდესაც ცვლადს ვსაზღვრავთ ფუნქციის გარეთ, ჩვენ ვამბობთ, რომ ეს ცვლადი გლობალურია. ეს იმითაა გამოწვეული, რომ ამ ცვლადზე წვდომა აქვს ნებისმიერ ფუნქციას და შეგვიძლია, შევცვალოთ ეს ცვლადი, როგორც მოგვესურვება.

var globalResult;

var addNumbers = function(num1, num2) {
  globalResult = num1 + num2;
  println("The global result is: " + globalResult);
};
addNumbers(5, 7);
println(globalResult);

როდესაც ზემოთ მოთავსებულ კოდს გავუშვებთ, შეცდომას არ მივიღებთ, რადგან ჩვენ განვსავზღვრეთ globalRestult ფუნქციის გარეთ, შესაბამისად, შეგვიძლია, მასზე წვდომა გვქონდეს კოდის ნებისმიერი სასურველი ადგილიდან.

ყოველი პროგრამირების ენა განსხვავდება, თუმცა JavaScript-ისთვის მნიშვნელოვანია, ფუნქციებს ჰქონდეთ „ფუნქციის წვდომის არეალი" - ფუნქციას შეუძლია, დაინახოს როგორც ლოკალური ცვლადები, რომლებიც მის შიგნითაა განსაზღვრული, ასევე - გლობალური ცვლადები, რომლებიც ფუნქციების გარეთაა განსაზღვრული, მაგრამ მას არ აქვს წვდომა სხვა ფუნქციებში განსაზღვრულ ცვლადებზე.

გსურთ, შეუერთდეთ დისკუსიას?

შესვლა

დავალაგოთ:

nozadzegrigol
გამოქვეყნების თარიღია 3 წლის წინ. მომხმარებლის nozadzegrigol გზავნილზე „გამარჯობა! var globalRes...“ პირდაპირი ბმული
გამარჯობა!

var globalResult;

var addNumbers = function(num1, num2) {
globalResult = num1 + num2;
println("The global result is: " + globalResult);
};
addNumbers(5, 7);
println(globalResult);

კონსოლში მაძლევს შეცდომას:
println is not function.

როგორ უნდა გასწორდეს პროგრამა?
Button navigates to signup pageდატოვეთ კომენტარი მომხმარებლის nozadzegrigol გზავნილზე „გამარჯობა! var globalRes...“
(2 მოწონება)
პასუხი
nozadzegrigol
გამოქვეყნების თარიღია 3 წლის წინ. მომხმარებლის nozadzegrigol გზავნილზე „გამარჯობა! რა განსხვავება...“ პირდაპირი ბმული
გამარჯობა!
რა განსხვავებაა შემდეგი ორი წესით დაწერილ ფუნქციებს შორის?
შედეგს ორივე ერთანირს მაძლევს კონსოლში.
1.
var addNumbers = function(num1, num2) {
globalResult = num1 + num2;
console.log("The global result is: " + globalResult);
};
addNumbers(5, 7);
globalResult;
VM48:3 The global result is: 12
12

2. function addNumbers(num1, num2) {
let globalResult = num1 + num2;
console.log("The global result is: " + globalResult);
};
addNumbers(5, 7);
globalResult;
VM65:3 The global result is: 12
12
Button navigates to signup pageButton navigates to signup page
(1 მოწონება)
პასუხი
nozadzegrigol
გამოქვეყნების თარიღია 3 წლის წინ. მომხმარებლის nozadzegrigol გზავნილზე „და კიდევ შემდეგ ორს შორის...“ პირდაპირი ბმული
და კიდევ შემდეგ ორს შორის:
1.
var addNumbers = function(num1, num2) {
var localResult = num1 + num2;
console.log("The local result is: " + localResult);
return localResult;
};
addNumbers(5, 7);
VM181:3 The local result is: 12
12

2.
function addNumbers(num1, num2) {
let localResult = num1 + num2;
console.log("The local result is: " + localResult);
return localResult;
};
addNumbers(5, 7);
VM189:3 The local result is: 12
12
Button navigates to signup pageButton navigates to signup page
(1 მოწონება)
პასუხი

გესმით ინგლისური? დააწკაპუნეთ აქ და გაეცანით განხილვას ხანის აკადემიის ინგლისურენოვან გვერდზე.