გრუვი

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

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

def a = 10

შეგვიძლია შევამოწმოთ a-ს მნიშვნელობა assert კეივორდის გამოყენებით

assert a == 10

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

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

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

println "${args[0]}'s kvadratia ${Math.pow (Integer.parseInt(args[0]),2)}"

ფაილი რომელშიც მოთავსებულია ეს გამოსახულება საკმარისია groovy-ს ბრძანებით გავუშვათ და მივიღებთ შედეგს

user@user-laptop:~$ groovy kvadrati 5
5's kvadratia 25.0

იგივე ფუნქციის შემსრულებელი ბრძანება დაწერილი ჯავაში:

    public class Kvadrati {
    public static void main(String[] args)
     {
      System.out.println(args[0]+"'s kvadratia " + Math.pow(Integer.parseInt(args[0]),2));
     }
    }

თავიდან უნდა მოვახდინოთ კომპილაცია და შემდგომ გავუშვათ ბაითკოდი.

     user@user-laptop:~$ javac Kvadrati.java
     user@user-laptop:~$ java Kvadrati 5
     5's kvadratia 25.0

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

     Adamiani petre = new Adamiani('Petre')
     petre.getSaxeli()

     String getSaxeliUkugmad(adamiani) {
     saxeli = adamiani.getSaxeli()
     return saxeli.reverse()
     }

 ჩართვები (Closure) 
გრუვის ენა ხელს უწყობს ჩართვებს. ჩართვა არის კოდის ნაწილი მოთავსებული ფიგურულ ფრჩხილებში {}, რომელიც მოქმედებს თავის შიდა სივრცეში და იყენებს გარეთა სივრცის ცვლადებს. ჩართვები წააგავენ ჯავის ფუნქციებს იმის გამონაკლისით რომ ჩართვა ობიექტს წარმოადგენს.

     def name = "Irakli"
     def printClosure = { println "Hello, ${name}" }
     printClosure()

ამ გრუვი კოდის შედეგია

     Hello, Irakli

ჩართვების გამოყენება ხშირად ხდება კრებულების(Collections) მანიპულაციის დროს. 
მაგალითად, ჯავაში კარგად ცნობილი სიების კლასი (java.util.List), რომელიც აგრეთვე გამოიყენება გრუვის კოდებში, ჩართვების გამოყენებით ამარტივებს სიის
ელემენტებზე სხვადასხვა მოქმედებების მოხდენას.

// სია რომელიც შეიცავს სამი String-ის ტიპის ელემენტს

    def myNameList = ["Irakli", "Aleko", "Tamuna"]
    myNameList.each {println it}

ამ გრუვი კოდის შედეგია

    Irakli
    Aleko
    Tamuna

სიების ფუნქცია each თითოეულ სიის ელემენტზე {println it} ჩართვას აწარმოებს. it არგუმენტი each ფუნციის გამოყენების დროს სიის მიმდინარე ელემენტს წარმოადგენს.

სქოლიო

კატეგორია:პროგრამირების ენები