Підручник Scala

Підсумок підручника Scala

Цей підручник Scala охоплює всі аспекти та теми Scala. Ви дізнаєтеся всі основи з нуля, наприклад, що таке scala, процес встановлення scala, програми Scala, функції Scala, відкладене оцінювання, інтерфейс типів, класи та об’єкти, успадкування, абстракції, Java і масштабні відмінності тощо.

Scala — це масштабована мова, яка використовується для написання програмного забезпечення для багатьох платформ. Тому він отримав назву «Scala». Ця мова призначена для вирішення проблем Java водночас будучи більш лаконічним. Спочатку розроблений Мартіном Одерскі, він був випущений у 2003 році.

Навіщо вивчати Scala

Ось головні причини вивчення мови програмування Scala:

• Scala легко освоїти для об’єктно-орієнтованих програмістів, Java розробників. Останнім часом вона стає однією з популярних мов.
• Scala пропонує першокласні функції для користувачів
• Scala можна виконувати на JVM, таким чином прокладаючи шлях для взаємодії з іншими мовами.
• Він розроблений для одночасних, розподілених і стійких додатків, керованих повідомленнями. Це одна з найвимогливіших мов цього десятиліття.
• Це лаконічна, потужна мова, яка може швидко розвиватися відповідно до попиту користувачів.
• Він об’єктно-орієнтований і має багато функцій функціонального програмування, що надає розробникам велику гнучкість для кодування у спосіб, яким вони хочуть.
• Scala пропонує багато типів качок
• У ньому менше шаблонів, якщо ви родом Java
• Фреймворки Lift and Play, написані на Scala, знаходяться на кривій зростання.

Як встановити Scala

Щоб почати писати програми Scala, її потрібно інсталювати на вашому комп’ютері. Для цього вам потрібно буде відвідати їхній сайт https://www.scala-lang.org/download/ щоб завантажити останню версію Scala.

Перейшовши за посиланням, ми перейшли до двох варіантів, які ми можемо вибрати для встановлення Scala на наших машинах. Для цього підручника Scala ми завантажимо IntelliJ IDEA.

Перейшовши за посиланням для завантаження, ви знайдете дві версії IntelliJ IDE.

Для цього підручника Scala ми завантажимо видання Community Edition, яке є безкоштовним і містить усе необхідне для написання програм Scala.

Крок 1) Виберіть Community Edition
На сторінці клацніть спадне меню Community Edition.

Він дає нам можливість завантажити IntelliJ IDE разом із JBR, який містить реалізацію JDK(Java Набір для розробки) OpenJDK, який Scala потрібен для компіляції та запуску коду.

Крок 2) Запустіть установку
Після завантаження IntelliJ двічі клацніть його, щоб запустити майстер інсталяції та дотримуйтеся діалогового вікна.

Крок 3) Виберіть місцеположення
Виберіть місце для встановлення IDE.

Якщо ви випадково не завантажили файл із JDK, ми все одно отримаємо підказку, де ми можемо перевірити його завантаження, установивши прапорець.

Крок 4) Натисніть «Далі».
Залиште інші параметри за замовчуванням такими, якими вони є, і натисніть «Далі».

Крок 5) Натисніть на значок запуску
Після завершення встановлення запустіть IntelliJ IDE, клацнувши піктограму запуску в меню запуску, як звичайну програму.

Вам все одно потрібно пройти додатковий крок додавання плагіна Scala до IntelliJ; це можна зробити, клацнувши спадне меню в меню конфігурації, розташованому в нижньому правому куті екрана, і вибравши параметр плагіна.

На вкладці Marketplace пошук Scala відобразить плагін як перший результат під тегом Languages.

Крок 6) Встановіть плагін
Натисніть «Установити», після чого плагін почне завантаження.

Крок 7) Перезапустіть IDE
Після завершення завантаження вам буде запропоновано перезапустити IDE, щоб установлений плагін почав працювати.

Після перезапуску ви опинитесь на тій же сторінці, що й раніше, коли ми запускали IDE, але цього разу ми вже встановили плагін Scala.

Програма Scala Hello World

Крок 1) Виберіть опцію «Створити проект», яка переведе нас на сторінку, де ми можемо вибрати тип мови, яку використовуватиме наш проект.

Крок 2) виберіть Scala, установивши прапорець Scala, і натисніть «Далі».

Крок 3) Виберіть місце для збереження файлу наших проектів і дайте нашому проекту назву.

Якщо каталог не існує, IntelliJ запропонує нам запитати дозвіл на створення папки. Прийміть і натисніть Готово. Ви перейдете до свого проекту Scala, який наразі не має коду Scala.

Завантаження деяких індексів займе деякий час, тому не хвилюйтеся, якщо ви не можете негайно щось зробити, поки внизу вашої IDE є індикатор прогресу. Це просто означає, що ваша IDE завантажує деякі файли, необхідні для запуску Scala та допомога з автозавершенням IDE.

Крок 4) Далі ми клацнемо вкладку проектів ліворуч від IDE та розгорнемо її, щоб побачити вміст нашого проекту.

На даний момент проект порожній і містить лише папку .idea та файл hello-world.iml, згенерований IDE. Нашим інтересом є папка src. Src — це місце, де ми зберігаємо вихідний код нашого проекту. Тут ми створимо наш перший файл Scala.

Крок 5) Клацніть правою кнопкою миші на src, щоб відкрити меню для створення нового файлу Scala.

Потім ми створимо ім’я для файлу, у цьому підручнику Scala ми використаємо hello, а потім виберемо зі спадного списку, що додати як вміст файлу Scala. Виберіть «Об'єкт»

Коли ми це зробимо, ми матимемо файл Scala, який містить об’єкт Singleton, який ми будемо використовувати для запуску нашого коду.

Тепер у вас є файл Scala з об’єктом Hello. Ви напишете свою першу програму, розширивши створений вами об’єкт за допомогою ключового слова App.

Розширення нашого об’єкта за допомогою програми повідомляє компілятору, який код виконувати, коли він запускає вашу програму. Одразу після розширення додатка ліворуч з’являється зелена стрілка, яка вказує на те, що тепер ви можете запускати програму.

Всередині об’єкта Hello ми пишемо одну функцію println(), яка використовується для виведення тексту в ньому на консоль. Ми запустимо наш код, натиснувши на зелену стрілку.

Натиснувши стрілку, ми побачимо опцію Виконати, привіт, після натискання її наш код почне компілюватися, і через кілька секунд ми побачимо результати нашої програми, надруковані з консолі, вбудованої в IntelliJ IDE.

І ось, ми успішно встановили Scala і запустили нашу першу програму.

Що ви можете зробити зі Scala

• Веб-розробка інтерфейсу за допомогою ScalaJS
• Мобільна розробка, обидва Android Розробка та IOS – зі Scala Native
• Бібліотеки на стороні сервера, такі як HTTP4S, Akka-Http, Play Framework
• Використання Інтернету речей
• Розробка ігор
• NLP – обробка природної мови з використанням набору бібліотек ScalaNLP
• Тестування сучасних методів програмування, таких як функціональне програмування та об’єктно-орієнтоване програмування
• Створюйте високопаралельну комунікаційну програму, використовуючи акторську бібліотеку для JVM, натхненну Erlang
• Використовуйте його для машинного навчання за допомогою бібліотек, таких як Figaro, яка виконує ймовірнісне програмування, і Apache Spark Що

Анонімні функції

У мові Scala є анонімні функції, які також називаються функціональні літерали. Будучи функціональною мовою, Scala часто означає, що розробники розбивають великі проблеми на безліч маленьких завдань і створюють багато функцій для вирішення цих проблем. Щоб полегшити створення функцій, Scala містить ці функції, які можна використовувати екземпляр без імені. Ми можемо призначити їх безпосередньо змінним або визначенням 'def', як показано в наведеному нижче прикладі Scala:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n *3

Потім ми можемо використовувати звичайний спосіб використання функцій, передаючи їм параметри, як показано нижче.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Ці методи стають у нагоді, коли ми хочемо мати чистий і стислий код. Ми можемо використовувати анонімні функції, коли визначаємо методи, які не є великими та не вимагають багато коду в своєму тілі. Вони дуже прості, і для їх створення не потрібна церемонія.

Ці методи не обмежуються функціями з аргументами та можуть використовуватися для створення екземплярів методів, які не приймають жодних аргументів.

val sayHello = ()=>{ println("hello") }

Більшість цих анонімних функцій використовуються в інших частинах нашого коду, де нам потрібно створити швидку функцію на місці.

Ще одна причина, чому ці функції також називаються вбудовані функції. Використання анонімних функцій є типовим шаблоном, який широко використовується в бібліотеці колекцій для виконання швидких дій над колекцією.

Наприклад, у нас є метод фільтра, який використовує вбудовану функцію/анонімну функцію для створення іншої колекції лише з елементами, які відповідають критеріям, визначеним нами в анонімній функції.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

Тут методи, які ми маємо як анонімні функції, перевіряють, чи є значення, яке ми отримуємо зі списку, парним і непарним, і повертаємо елемент.

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

У Scala також можна використовувати символи узагальнення, якщо параметр нашої анонімної функції не має імені. Наприклад

var timesTwo = (_:Int)*2

timesTwo(5)
//10

У цьому випадку ми не називаємо параметр, який ми передаємо. Єдине, що ми використовуємо підкреслення для його представлення.

Ледача оцінка

Більшість мов послідовно обчислюють змінні та параметри функцій, один за одним. У Scala ми маємо ключове слово під назвою lazy, яке допомагає працювати зі значеннями, які ми не хочемо оцінювати, доки на них не буде посилання.

Змінна, позначена як лінива, не буде оцінюватися там, де вона визначена, це широко відомо як оцінка з нетерпінням, вона буде оцінена лише тоді, коли на неї посилається дещо пізніше в коді.

Це може бути корисним, коли оцінка значення може бути дорогим обчисленням. Якщо це не те, що значення завжди потрібне, ми можемо врятувати себе від виконання дорогих обчислень, які можуть уповільнити наше програмне забезпечення, зробивши нашу змінну ледачою.

lazy val myExpensiveValue = expensiveComputation

def runMethod()={
    if(settings == true){
        use(myExpensiveValue)
    }else{
        use(otherValue)
    }
}

Це не єдиний випадок використання відкладених змінних. Вони також допомагають вирішити проблеми циклічної залежності в коді.

Якщо параметри false, нам може не знадобитися використовувати myExpensiveValue, що може позбавити нас від виконання дорогих обчислень, що допомагає гарантувати, що користувачі приємно проводять час, користуючись нашою програмою, оскільки їхні інші потреби можна правильно обчислити, не перевантажуючи ОЗУ.

Якщо параметри false, нам може не знадобитися використовувати myExpensiveValue, що може позбавити нас від виконання дорогих обчислень, що допомагає гарантувати, що користувачі приємно проводять час, користуючись нашою програмою, оскільки їхні інші потреби можна обчислити належним чином, не перевантажуючи ОЗУ.

Лінь також допомагає з аргументами функції, де аргументи використовуються лише тоді, коли на них є посилання всередині функції. Ця концепція називається параметрами виклику за іменем.

def sometimesUsedString(someValue:String, defaultValue:=> String)={
 if(someValue != null){
   use(defaultValue)
 }else{
   use(someValue)
   }
 }

Багато мов використовують метод виклику за значенням для оцінки аргументів. Параметр, переданий через call-by-name, буде оцінено лише за потреби в тілі функції та не буде оцінено до цього. Після того, як значення оцінено, воно зберігається та може бути повторно використано пізніше без необхідності повторної оцінки. Концепція, відома як запам'ятовування.

Типовий висновок

У Scala вам не потрібно оголошувати типи для кожної змінної, яку ви створюєте. Це тому, що компілятор Scala може робити висновок про типи на основі оцінки правої частини. Це дозволяє вашому коду бути більш лаконічним – це звільняє нас від шаблонного написання там, де очікуваний тип очевидний

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compile infers that third is of type String

Функція вищого порядку

Функція вищого порядку — це функція, яка може приймати функції як аргументи та повертати функцію як тип повернення. У Scala функції вважаються громадянами першого класу. Використання цих функцій у такий спосіб дає нам змогу бути дуже гнучкими щодо того, які програми ми можемо створювати. Ми можемо динамічно створювати функції та динамічно передавати їх іншим функціям.

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int ={
    myMathFunction(n)
}

У наведеній вище функції ми передаємо int і функцію, яка приймає int і повертає int. Ми можемо передати будь-яку функцію цього підпису. Під сигнатурою ми маємо на увазі вхід і вихід функції. Сигнатура Int=>Int означає, що функція приймає Int як вхідні дані та повертає Int як вихідні дані.

Сигнатура ()=>Int означає, що функція нічого не приймає як вхідні дані та повертає Int як вихідні дані. Прикладом такої функції може бути функція, яка генерує для нас випадковий int.

def generateRandomInt()={
 return scala.util.Random.nextInt()
}

Наведена вище функція має сигнатуру ()=>Int

Ми можемо мати функцію, яка має підпис scala ()=>Unit. Це означає, що функції нічого не приймають і не повертають тип. Функція може виконувати певні обчислення, змінюючи щось на виконання заздалегідь визначеного.

Проте такі методи не заохочуються, оскільки вони здаються чорною скринькою, яка може впливати на систему невідомими способами. Вони також не піддаються перевірці. Наявність явних типів вводу та виводу дозволяє нам міркувати про те, що робить наша функція.

Функція вищого порядку також може повертати функцію.

Наприклад, ми могли б створити метод, який створюватиме функцію степеня, тобто бере число та застосовує до нього ступінь.

def powerByFunction(n:Int):Int=>Int = {
  return (x:Int)=> scala.math.pow(x,n).toInt
}

Наведена вище функція приймає int. Наш тип повернення є анонімною функцією, яка приймає Int x, * ми використовуємо int x як аргумент для функції ступеня.

Заготівля

У Scala ми можемо перетворити функцію, яка приймає два аргументи, в одну, яка приймає по одному аргументу. Коли ми передаємо один аргумент, ми частково застосовуємо його і отримуємо функцію, яка приймає один аргумент для завершення функції. Каррінг дозволяє нам створювати функції, частково додаючи деякі аргументи.

Це може бути корисно для динамічного створення функцій до того, як у нас буде повний набір аргументів

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Якщо нам потрібно створити функцію, яка множить на певне число, нам не потрібно створювати інший метод множення.

Ми можемо просто викликати .curried у нашій функції вище та отримати функцію, яка спочатку приймає один аргумент і повертає частково застосовану функцію

def multiplyTwoNumbers(n:Int)(m:Int): Unit ={
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Збірка візерунків

Scala має потужний вбудований механізм, який допомагає нам перевірити, чи відповідає змінна певним критеріям, подібно до того, як ми робили б у операторі switch у Java або в серії операторів if/else. У мові є відповідність шаблону, за допомогою якої ми можемо перевірити, чи належить змінна до певного типу. Зіставлення шаблонів у Scala є потужним і може використовуватися для деструктурування компонентів, які мають метод unaply, щоб отримати поля, які нас цікавлять, безпосередньо зі змінної, яку ми зіставляємо.

Зіставлення шаблону Scala також забезпечує більш приємний синтаксис порівняно з інструкцією switch.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Ми порівнюємо нашу змінну з набором параметрів, і коли змінна, яку ми зіставляємо, відповідає критеріям, вираз у правій частині жирної стрілки (=>) обчислюється та повертається як результат відповідності.

Ми використовуємо підкреслення, щоб виявити випадки, які не відповідають нашому коду. Він відображає поведінку випадку за замовчуванням при роботі з операторами switch.

class Animal(var legs:Int,var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //case we have a type we don't recognize do sth else
}

У наведеному вище коді ви можете дізнатися тип змінної myItem і на основі цього перейти до певного коду.

Зіставлення шаблону перевіряє, чи збігається змінна

Підкреслення працює як заповнювач, який відповідає будь-якій іншій умові, яка не відповідає іншим елементам у наведених вище операторах case. Ми беремо змінну myItem і викликаємо метод match.

• ми перевіряємо, чи myItem є істинним, використовуючи та виконуємо деяку логіку з правого боку жирної стрілки «=>».
• ми використовуємо підкреслення, щоб зіставити все, що не збігається з будь-яким оператором case, який ми визначили в коді.

З класами Case ми навіть можемо піти далі та деструктурувати клас, щоб отримати поля всередині об’єкта.

Використовуючи ключове слово sealed для визначення наших класів, ми отримуємо перевагу від того, що компілятор ретельно перевіряє випадки, з якими ми намагаємося зіставити, і попереджає нас, якщо ми забуваємо обробити певний.

Незмінюваність

За допомогою ключового слова val можна створювати значення, які не можуть бути змінені іншими функціями Scala. Це досягається в Java за допомогою ключового слова final. У Scala ми робимо це, використовуючи ключове слово val під час створення змінної замість використання var, яке є альтернативою, яку ми б використали для створення змінної змінної.

Змінна, визначена за допомогою ключового слова val, доступна лише для читання, тоді як змінна, визначена за допомогою var, може бути прочитана та змінена іншими функціями або довільно користувачем у коді.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Спроба призначити значення myNumber після того, як ми оголосили його як val, викликає помилку під час компіляції або «перепризначення значення».

Навіщо використовувати незмінність?

Незмінність допомагає нам запобігти неочікуваній зміні наших значень кодом та іншими програмістами, що призведе до неочікуваних результатів, якщо вони мають намір використовувати збережене нами значення, замість цього вони можуть створити його копію. Таким чином, запобігаються помилки, які можуть бути спричинені кількома акторами, які змінюють ту саму змінну.

Класи та об'єкти

Ми всі знаємо, що об’єкти — це сутності реального світу, а клас — це шаблон, який визначає об’єкти. Класи мають як стан, так і поведінку. Стани є або значеннями, або змінними. Поведінки — це методи в Scala.

Давайте розглянемо, як можна визначити клас, створити його екземпляр і використовувати за допомогою Scala.

Тут клас під назвою Rectangle, який має дві змінні та дві функції. Ви також можете використовувати параметри l і b безпосередньо як поля в програмі. У вас є об’єкт, який має основний метод і створив екземпляр класу з двома значеннями.

приклад:

class Rectangle( l: Int,  b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Усі поля та метод за замовчуванням загальнодоступні в Scala. Важливо використовувати перевизначення, оскільки метод toString визначено для Object у Scala.

Спадкування

Scala має кілька типів успадкування (наприклад, однорівневий, багаторівневий, множинний, ієрархічний, гібридний), які мають багато спільного з традиційними формами, які можна знайти в Java. Ви можете успадковувати як класи, так і риси. Ви можете успадкувати членів одного класу в інший клас за допомогою ключового слова “extends”. Це забезпечує повторне використання.

Можливе успадкування від одного або кількох класів. Також можна успадковувати від підкласів, які самі мають свої суперкласи, створюючи ієрархію успадкування в процесі.

У наведеному нижче прикладі Scala базовим класом є Circle, а похідним класом є Sphere. Коло має значення радіуса, яке успадковується в класі Sphere. Метод calcArea замінюється за допомогою ключового слова override.

приклад:

class Circle {
  val radius = 5;
  def calcArea = {
    println(radius * radius )
  }
}
class Sphere extends Circle{
 override def calcArea = {
    println(radius * radius * radius )
  }
}
  object SphereObject{
    def main(args : Array[String]){
      new Sphere().calcArea 
    }
  }

Абстракція

У Scala ми можемо створювати абстрактні методи та поля-члени, використовуючи абстрактні класи та ознаки. Всередині абстрактних класів і ознак ми можемо визначати абстрактні поля, не обов’язково їх реалізовуючи.

приклад:

trait MakesSound{
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int){
    val creatureName:String

    def printLegs():String={
        return s"$creatureName has this number of legs: $legs"
    }
}

Ці поля реалізуються класами, які розширюють властивість або абстрактний клас. Ви можете використовувати ознаки для створення контрактів щодо того, що наша програма повинна мати можливість робити, а потім реалізувати ці методи пізніше.

trait DatabaseService{
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

Таким чином, ми можемо спланувати, як виглядатиме наша програма, не впроваджуючи методи, які можуть допомогти нам уявити, як виглядатимуть різні методи. Це слідує шаблону, відомому як програмування до абстракцій, а не фактичної реалізації.

Клас, перед яким стоїть ключове слово abstract, може містити як абстрактні, так і неабстрактні методи. Але множинне успадкування не підтримується в абстрактному класі. Отже, ви можете розширити щонайбільше один абстрактний клас.

Об'єкти Singleton

Singleton — це клас, екземпляр якого створюється лише один раз у програмі. Це з популярного та корисного шаблону програмування, відомого як «шаблон одного елемента». Це корисно для створення екземплярів, які призначені для тривалого життя та будуть загальнодоступними у вашій програмі, стан якої є невід’ємною частиною координації подій системи. Створити такий клас у Scala легко, оскільки Scala надає нам прості засоби створення одиночних елементів за допомогою ключового слова object.

object UserProfile{
    var userName=""
    var isLoggedIn:Boolean = false
}

Потім ми можемо посилатися на цей об’єкт у всій нашій програмі з гарантією, що всі частини нашої програми бачитимуть ті самі дані, оскільки є лише один його екземпляр.

def getLoggedInStatus():Boolean={
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean={
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return  UserProfile.isLoggedIn
}

Концепція статичних членів відсутня в Scala, тому вам потрібно використовувати одиночні об’єкти, які діють як статичні члени класу.

Неявні класи

Неявні класи — це нові функції, додані після версії 2.1. В першу чергу, щоб додати новий функціонал до закритих класів.

Неявне ключове слово має бути визначене в класі, об’єкті чи ознакі. Основний конструктор неявного класу повинен мати рівно один аргумент у першому списку параметрів. Він також може містити додатковий неявний список параметрів.

У наведеному нижче прикладі Scala додано нову функцію для заміни голосних у рядку на *.

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Вам потрібно імпортувати в клас, де ви його використовуєте.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Об'єктно-орієнтоване програмування (ООП) проти функціонального програмування (FP)

В ООП програми створюються шляхом групування даних і функцій, які працюють з цими даними, у тісно зв’язані одиниці. Об’єкти несуть свої дані в полях і методах, які з ними працюють. У цьому стилі програмування основною абстракцією є дані, оскільки створені методи призначені для роботи з даними.

Функціональне програмування, з іншого боку, розділяє дані та функції, які працюють з даними. Це дозволяє розробникам розглядати функції як абстракцію та рушійну силу під час моделювання програм.

Scala забезпечує функціональне програмування, маючи функції як громадяни першого класу, дозволяючи передавати їх як значення іншим функціям і також повертати їх як значення. Поєднання цих двох парадигм зробило Scala чудовим вибором для створення складного програмного забезпечення в різних галузях, таких як Data Science.

Важливі фреймворки на Scala

Ось кілька важливих фреймворків Scala

• Play це фреймворк веб-програми з відкритим кодом, який використовує Архітектура MVC. Випущений у 2007 році та тепер ліцензований під Apache, він став найпопулярнішим фреймворком на GitHub у 2013 році. Такі компанії, як LinkedIn, Walmart, Samsung, Eero використовують цей фреймворк.
• ліфт це ще один безкоштовний веб-фреймворк, написаний на Scala, запущений у 2007 році. Foursquare використовує фреймворк Lift. Це високопродуктивний каркас, який швидше створюється.
• Акка
• коти
• Spark

Підтримка паралелізму

• Значення в Scala за замовчуванням незмінні. Це робить його дуже адаптивним до одночасного середовища.
• У Scala є багато функцій, які роблять її найкращою для одночасних програм.
• Futures і Promises полегшують асинхронну обробку даних, таким чином підтримуючи паралелізм.
• Akka – набір інструментів, який використовує модель паралельного доступу Actor. Існує кілька акторів, які діють, коли отримують повідомлення.
• Паралелізм із використанням потоків із Java також може підтримуватися в Scala.
• Потокова обробка — це ще одна чудова функція, яка забезпечує постійну обробку даних у режимі реального часу.

Scala має одні з найкращих бібліотек паралелізму Java екосистеми.

• рідний Java теми
• Волокна з таких бібліотек, як Vertex
• ZIO – бібліотека, яка містить примітиви, які допомагають нам працювати з паралелізмом і асинхронними обчисленнями
• STM – транзакція
• Майбутнє – вбудовано в мову Scala

Java проти Scala

Ось основні різниця між Java і Scala.

масштаб	Java
Більш компактний і лаконічний	Порівняно більші фрагменти коду
Спроектовано та розроблено як об’єктну, так і функціонально-орієнтовану мову. Підтримує широкий спектр функцій функціонального програмування, таких як паралелізм, незмінність.	Спочатку розроблена як об’єктно-орієнтована мова, а нещодавно почала підтримувати функції функціонального програмування. Все ще не є сильною як функціональна мова програмування.
Використовує модель актора для підтримки паралельності, яка є сучасною	Використовує звичайну модель на основі потоків для паралелізму.
Підтримує фреймворки – Play, Lift	Підтримує Spring, Grails тощо
Підтримує відкладене оцінювання	Не підтримує відкладене оцінювання
Без статичних членів	Містить статичні елементи
Підтримує перевантаження оператора	Не підтримує перевантаження операторів
Компіляція вихідного коду відбувається порівняно повільно	Компіляція вихідного коду швидше, ніж Scala
Риси – діяти як Java 8 інтерфейси	Java 8 інтерфейсів намагаються подолати розрив між класами та інтерфейсами
Потрібне переписування	Переписувати не потрібно
Немає гарантій щодо кодів без помилок	Повна гарантія дрібних дефектів
Підтримує зворотну сумісність.	Scala не підтримує зворотну сумісність.
Operaтори трактуються по-різному в Java і не є викликами методів.	Усі оператори над записами створюються через метод, що викликається в Scala.
Підтримує множинне успадкування за допомогою класів, але не за допомогою абстрактних класів	Не підтримує множинне успадкування за допомогою класів, а за допомогою інтерфейсів
Код написаний у компактній формі.	Код написаний у довгій формі.
Scala не містить ключового слова static.	Java містить ключове слово static.

Підсумки

У цьому посібнику ви дізналися, як розпочати роботу зі Scala. Ви також дізналися про функціональні та об’єктно-орієнтовані функції. Ви також виявили схожість і відмінності між ними Java і Scala. Цей підручник повинен був допомогти вам із великою різноманітністю прикладів, які добре продемонстровано.