Използване на класове в CoffeeScript

Едно от най -важните неща, които ни помагат да дефинираме нашето приложение, е използването на класове, тъй като с тях можем да дефинираме обекти, моделирани от реалния живот и преминаването им към цифровия свят става много по -лесно.
В CoffeeScript изграждането на клас и създаването му е много просто, всъщност синтаксисът му е толкова минималистичен, че за нас е много лесно да го запомним, вместо да направим дефиниция на класове директно в JavaScript Това е нещо малко по -тромаво и това може да ни отнеме повече време от очакваното.
ИзискванияЗа да завършим този урок, трябва да имаме функционална инсталация на CoffeeScript, ние също се нуждаем от разрешения за писане на файлове и изпълнение CoffeeScript на компютъра, където правим урока. Нуждаем се от текстов редактор, за да можем да напишем кода, който ще изпълним, така че да имаме нещо постоянно, а не всичко в конзолата.
Класът не е нищо повече от име и някои свойства, които определят поведението му, въз основа на тази концепция, в която можем да определим клас CoffeeScript както следва:

 клас Ученик

Това е всичко, което трябва да направим, по прост начин вече сме изградили първия си клас CoffeeScriptКакво се случва, ако искаме да включим свойство, за да можем да го използваме, защото просто правим екземпляр и добавяме това свойство, нека видим:

 студент = нов Студент () student.name = "Каролина"

Сега нека видим как на следното изображение като CoffeeScript трансформираме целия ни код в JavaScript чисто при компилиране, нека запомним командата за това, която би била кафе -c име на файл.кафе:

След това забелязваме как синтаксисът на JavaScript pure е много по -обширен и сложен от трите реда код, които направихме CoffeeScript, това е силата на този език, която ни позволява наистина да се посветим на нашето приложение.
Едно от нещата, които се използват най -много в Обектно-ориентирано програмиране е да добавяме методи към класовете, тъй като те, освен свойствата, ще ни дадат представа за това какво може или не може да направи нашият обект, например ако продължим с Студентски клас Можем да създадем метод за него, в който неговият обект изразява съобщение, нека да видим как да го постигнем:

 клас Учениците говорят: -> console.log "Hello World!"

Ако след това създадем обект от същия клас, вече бихме могли да използваме същия метод. Например:

 студент = нов Studentstudent.talk ()

С това се уверяваме, че нашият метод може да се използва многократно, стига да правим няколко екземпляра, което дава на нашия код една от характеристиките на обектната ориентация, която е повторна употреба. Сега ще предефинираме нашия код, така че да приема аргументи, с това можем да направим много повече от обикновен печат по конзола, нека видим:

 клас Студентска беседа: (име) -> console.log "Здравей # {име}!" студент = нов Studentstudent.talk ("Каролина")

Нека да видим как всичко това се превежда в код JavaScript когато съставяме:

Нещо важно, което можем да направим, когато конструираме обекти, получени от класове, е да поддържаме тяхната стойност през целия им живот в нашето приложение, с това можем да направим компоненти, които да имат достъп до техните свойства чрез методи и по този начин да ги използваме в различни части на нашето приложение.
За да манипулирате собственост вътре CoffeeScript просто трябва да използваме @ оператор последвано от името на свойството за използване, което може да бъде кодирано, както следва:

 клас Студент говори: () -> console.log „Здравей, # {@ name}!“

Нека да видим как изглежда това, когато се изпълнява директно в конзолата:

След като това стане, нека видим как изглежда нашият компилиран код JavaScript чисто:

Разликата в количеството на кода е забележителна и само за да се направи нещо толкова просто като дефиниране на клас с метод, след което да се създаде екземпляр и да се извика създаденият метод.
Има случаи, когато дефиницията на нашия клас ни кара да създаваме методи, които трябва да бъдат извикани в други, това, за да се постигне по -малко повтарящо се и по -функционално програмиране, нека видим как можем да го направим, като използваме следния код, написан на CoffeeScript.

 клас Студент говори: () -> console.log "Здравейте, казвам се: # {@ name}!" @knowAge () knowAge: () -> console.log "Моята възраст е: # {@ age}" student = new Student () student.name = "Vanessa" student.age = “23” student.talk ()

Нека да видим как в конзолата можем да видим резултата от изпълнението на предишния код:

Досега дефинирахме свойствата на обекта, след като го инициализирахме, въпреки че това е жизнеспособна практика, когато трябва да създаваме обекти с много свойства, това може да бъде трудно да се поддържа.
Най -доброто в случаите, когато трябва да работим с много обекти и много свойства, е да можем да използваме силата на строителиС тях можем да дадем живот на нашия обект директно, без да се налага да дефинираме различните свойства по „ръчен“ начин. За да определите конструктор, използвайте структура, подобна на следната:

 клас Конструктор на ученик: (име, възраст) -> @име = име @възраст = възраст говори: () -> console.log "Здравейте, казвам се: # { @name}!" @saberEdad () saberEdad: () -> console.log "Моята възраст е: # {@ age}"

Ако погледнем дефиницията на класа, конструкторът не е нищо повече от метод, интересното е, че когато се извика строител вече CoffeeScript той знае, че това е специален метод за нашия клас и ще го третира като такъв, затова, когато ще създаваме екземплярите на нашия клас, не е нужно да го наричаме изрично. Нека да видим пример за това как сега можем да дефинираме нашите обекти:

 студент = нов студент ("Каролина", "26") студент.speaking ()

Виждаме, че не трябваше да дефинираме имота Име нито имота възраст, ние просто предаваме стойностите на конструктора в реда, в който ги дефинираме в нашия клас и той свършва останалата част от работата вместо нас. Разбира се, този пример е много опростен, но нека си представим, че трябва да създадем екземпляри от стотици обекти със стойности, които идват от постоянен източник като база данни.
Нека видим на следващото изображение как изглежда нашият нов код, след като бъде компилиран и преведен JavaScript чисто:

В този случай виждаме това JavaScript не използва ключовата дума строител при конструирането на метода, който дефинираме в CoffeeScript, в този момент започваме да виждаме по по -директен начин разликата между езиците, в допълнение към това, което решихме в около 12 или 13 реда код, в JavaScript стават повече от 20 реда, нещо, което трябва да вземем предвид, когато правим големи приложения.
Едно от предимствата на работата с обектно-ориентирано програмиране е, че можем да го направим наследство класове, това означава да можете да създавате нови класове и да приемате функционалността на класовете родители, с това намаляваме броя на елементите, които трябва да създадем от нулата, тъй като при наследяването ние приемаме всички методи и свойства на родителския клас, в дъщерния клас или новия клас трябва само да дефинираме методите и свойствата, които са изключителни за него.
Може би за тези, които са нови в програмирането, тази концепция е малко объркваща или сложна, но като погледнем следния пример със сигурност ще бъдем малко по -ясни какво можем да постигнем.

 клас Човек, който трябва да знае Възраст: () -> console.log "Моята възраст е: # {@ age}" клас Ученикът разширява Лицето за говорене: () -> console.log "Здравей # {@ name}!" студент = нов Student () student.age = "30" student.name = "Jon" student.knowAge ()

Анализирайки виждаме как имаме клас Лице и този има метод knowAge () с които отпечатваме от конзолата възрастта на екземпляра, когато създаваме класа Студент казваме му, че наследява от Лице така неявно нашият нов клас вече има метода knowAge () дори и да не е дефинирано в класа.
Нека видим на следващото изображение как изглежда нашият нов код, след като бъде компилиран и преведен JavaScript чисто:

След това можем да видим, че нашият код JavaScript е доста сложен за определяне на наследството, но когато се използва CoffeeScript оптимизацията му е изключително висока. Ако видим помощната програма, нека си представим много сложни класове като компоненти на приложението, които могат да ни дадат множество функционалности в новите ни класове, без да се налага да пишем повече от конкретния код, от който наистина се нуждаем.
С това завършихме този урок, тъй като виждаме света на класовете в CoffeeScript Не е толкова сложно, колкото изглеждаше на пръв поглед, всичко се крие в познаването на основите и философията на обектно-ориентираното програмиране. Това, което можем да уверим, е, че използването на CoffeeScript като език, прави сложността на използването на класове в JavaScript спадат значително, тъй като синтаксисът му е много по -близо до езици като Python или Руби те го правят много по -елегантен и по -малко объркващ при четене на разработения код.Хареса ли ви и помогнахте на този урок?Можете да възнаградите автора, като натиснете този бутон, за да му дадете положителна точка