Підручник Scala

⚡ Розумний підсумок

У посібнику зі Scala представлена ​​статично типізована мова програмування на основі JVM, яка поєднує об'єктно-орієнтоване та функціональне програмування. Посібник охоплює встановлення, синтаксис, основні функції та фреймворки, що роблять Scala ідеальною для створення паралельних, масштабованих та лаконічних сучасних застосунків.

  • 🔘 Гібридна парадигма: Scala поєднує об'єктно-орієнтоване та функціональне програмування на JVM, дозволяючи розробникам поєднувати незмінність, першокласні функції та традиційні ієрархії класів.
  • ☑️ Стислий синтаксис: Виведення типів, анонімні функції та зіставлення зі зразком зменшують шаблонність порівняно з Java поки кіping код виразний та читабельний.
  • ✅ Налаштування за допомогою IntelliJ: Встановіть середовище розробки Community Edition, додайте плагін Scala та створіть об'єкт, який розширює додаток для запуску першої програми Hello World.
  • 🧪 Функціональні структурні блоки: Ліниве обчислення, каррування, функції вищого порядку та незмінність через val підтримують чистий та передбачуваний код.
  • 🛠️ Паралелізм та фреймворки: Актори Акки, Ф'ючерси, П'єса, Ліфт та Spark роблять Scala сильним вибором для розподілених систем, веб-додатків та інженерії даних.

Підручник Scala

Що таке Scala?

масштаб — це статично типізована мова програмування, яка поєднує об'єктно-орієнтоване та функціональне програмування для покращення масштабованості застосунків. Scala працює переважно на платформі JVM, і розробники також можуть використовувати її для написання програмного забезпечення для нативних платформ через Scala-Native або для браузера через ScalaJs та... JavaScript час виконання.

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

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

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

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

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

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

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

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

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

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

Сторінка завантаження IntelliJ Community Edition

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

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

Завантажте IntelliJ з JBR

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

Майстер встановлення IntelliJ

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

Виберіть папку для встановлення

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

Прапорець JDK під час встановлення

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

Параметри інсталятора за замовчуванням

Програма Scala Hello World

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

Екран привітання IntelliJ

Вам все ще потрібно додати плагін Scala до IntelliJ. Клацніть випадаюче меню в меню налаштування в правому нижньому куті екрана та виберіть опцію Плагіни.

Налаштування меню для плагінів

Маркетплейс плагінів IntelliJ

На вкладці «Маркетплейс» знайдіть Scala. Плагін відображається як перший результат під тегом «Мови».

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

Встановлення плагіна Scala

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

Перезапустіть запит IntelliJ

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

Крок 8) Виберіть «Створити проєкт», що переведе на сторінку, де можна вибрати мову для проєкту.

Створення нового проекту в IntelliJ

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

Виберіть мову Scala

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

Назвіть та знайдіть проект

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

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

Крок 11) Клацніть вкладку «Проект» ліворуч від IDE та розгорніть її, щоб побачити вміст проекту.

Розгорнути вкладку проекту

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

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

Створіть новий файл Scala

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

Виберіть тип об'єкта

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

Створено об'єкт Singleton

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

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

Виконати стрілку в IntelliJ

Виконати опцію «Привіт»

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

Клацання стрілки відкриває опцію «Виконати Hello». Її вибір компілює код, і через кілька секунд вивід програми з'являється в консолі IntelliJ.

Вивід Hello World у консолі

Ви успішно встановили Scala та запустили свою першу програму.

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

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

  • Розробка фронтенд-сайтів на ScalaJS.
  • Мобільна розробка для Android та iOS зі Scala Native.
  • Серверні бібліотеки, такі як HTTP4S, Akka-Http та Play Framework.
  • Програми Інтернету речей (IoT).
  • Розробка гри.
  • Обробка природної мови з використанням набору бібліотек 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") }

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

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

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, не обчислюється там, де вона визначена, що зазвичай відоме як нетерпляча обчислення. Вона обчислюється лише тоді, коли на неї посилаються пізніше в коді.

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

lazy val myExpensiveValue = expensiveComputation

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

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

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

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

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

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

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

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

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compiler 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 означає, що функція нічого не приймає на вхідні дані та повертає ціле число на вихід. Прикладом такої функції є функція, яка генерує випадкове ціле число.

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

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

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

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

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

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

Функція вище приймає ціле число. Тип повернення – це анонімна функція, яка приймає ціле число. x і використовує його як аргумент для степеневої функції.

Заготівля

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

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

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

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

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

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

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

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

Зіставлення зі зразком 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 _ => //unknown type, do something else
}

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

Зіставлення зі зразком перевіряє, чи відповідає змінна кожному випадку по порядку.

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

  • Перевірте, чи myItem is true та запустіть логіку праворуч від жирної стрілки “=>”.
  • Використовуйте символ підкреслення для зіставлення будь-чого, що не відповідає жодному з операторів case, визначених у коді.

За допомогою класів case ви можете деструктуризувати клас до extract полів всередині об'єкта.

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

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

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

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

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

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

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

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

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

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

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

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

приклад:

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 a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

Усі поля та методи в Scala за замовчуванням є публічними. Важливо використовувати override оскільки toString вже визначено для кожного об'єкта в 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
    }
  }

Abstracції

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

приклад:

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"
    }
}

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

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

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

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

Об'єкти Singleton

Синглтон – це клас, екземпляр якого створюється лише один раз у програмі. Він походить від популярного та корисного шаблону програмування, відомого як «шаблон синглтона». Він корисний для створення екземплярів, які призначені для тривалого існування та загального доступу протягом усієї програми, де стан є невід'ємною частиною координації подій у системі. Створення такого класу в Scala просте, оскільки Scala надає простий спосіб створення синглтонів за допомогою… object keyword.

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.10, і вони використовуються переважно для додавання нової функціональності до існуючих закритих класів.

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

У наведеному нижче прикладі 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)
}

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

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

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

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

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

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

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

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

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

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

  • рідний Java нитки.
  • Волокна з бібліотек, таких як Vertx.
  • ZIO, бібліотека, яка містить примітиви для допомоги в управлінні паралельними та асинхронними обчисленнями.
  • Програмна транзакційна пам'ять (STM) для транзакцій.
  • Future, вбудований у мову Scala.

Java проти Scala

Ось основні відмінності між Java і Scala.

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

Поширені запитання

Scala має крутішу криву навчання, ніж Java оскільки він поєднує об'єктно-орієнтований та функціональний стилі. Однак розробники з Java досвідчені зазвичай швидко опановують основи. Практикуйте з невеликими проектами, і Scala REPL пришвидшує навчання.

Так. Scala продовжує працювати на великих системах у компаніях, що використовують Akka, Sparkта Kafka. Попит залишається високим у сфері інженерії даних, фінтех та розподілених систем, де цінними є продуктивність JVM та функціональне програмування.

Так. Сучасні помічники з кодування штучного інтелекту розуміють синтаксис Scala, систему типів та фреймворки, такі як Akka та SparkВони допомагають генерувати шаблони, пропонувати функціональні шаблони, пояснювати помилки компілятора та рефакторити код, пришвидшуючи розробку як для початківців, так і для експертів.

Scala керує Apache Spark, провідний двигун для обробки великомасштабних даних у конвеєрах штучного інтелекту. Бібліотеки, такі як Breeze, Smile та Figaro, підтримують числові обчислення, машинне навчання та ймовірнісне моделювання, що робить Scala сильним вибором для обробки виробничих даних.

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

Підсумуйте цей пост за допомогою: