Scala for Backend Engineering & Functional Programming · Lekcja

Parsowanie JSON

Przekształci Pan/Pani tekst w wartości JSON.

Lekcja 1 z 413 kroki

Parsowanie JSON to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Dlaczego Circe?

Circe to popularna biblioteka JSON dla Scali, zbudowana na funkcyjnym ekosystemie cats.

Stawia na bezpieczeństwo typów i niezmienność: analizowanie zwraca Either zamiast zgłaszać wyjątek, a dekodowanie tworzy wartości typowane zamiast map bez określonego typu.

W tej lekcji omówimy zamianę surowego tekstu JSON na model Json biblioteki Circe.

Dodawanie zależności

Circe jest dostarczane jako kilka modułów. Do analizowania i korzystania z podstawowego modelu potrzebujesz circe-core oraz circe-parser.

Moduł circe-generic dodaje automatyczne wyprowadzanie kodeków, które omówimy w późniejszych lekcjach.

libraryDependencies ++= Seq(
  "io.circe" %% "circe-core" % "0.14.6",
  "io.circe" %% "circe-parser" % "0.14.6"
)

Funkcja parse

Punktem wejścia do odczytywania JSON jest io.circe.parser.parse.

Przyjmuje ona String i zwraca Either[ParsingFailure, Json]. Lewa strona zawiera błędy składni, a prawa — przeanalizowane drzewo.

import io.circe.parser._

val result = parse("{\"name\": \"Ada\", \"age\": 36}")
// result: Either[ParsingFailure, Json]

Obsługa błędów analizowania

Ponieważ parse zwraca Either, błędy obsługujesz jawnie za pomocą dopasowania wzorców lub kombinatorów zamiast try/catch.

Element ParsingFailure zawiera czytelny dla człowieka komunikat opisujący problem ze składnią.

parse("{ not valid }") match {
  case Right(json) => println(json)
  case Left(err)   => println(s"Failed: ${err.message}")
}

Model Json

Pomyślnie przeanalizowana wartość to Json — niezmienne drzewo reprezentujące jeden z sześciu typów JSON: obiekt, tablicę, ciąg znaków, liczbę, wartość logiczną lub null.

Możesz ją sprawdzać za pomocą predykatów takich jak isObject albo zastosować fold do jej struktury.

val json = parse("[1, 2, 3]").getOrElse(Json.Null)
println(json.isArray)   // true
println(json.isObject)  // false

Nawigowanie za pomocą kursora

Aby odczytać zagnieżdżone dane, wywołaj .hcursor na wartości Json. HCursor to zipper, który pozwala poruszać się po drzewie.

Użyj downField, aby przejść do klucza obiektu.

val json = parse("{\"user\": {\"name\": \"Ada\"}}").toOption.get
val cursor = json.hcursor
val name = cursor.downField("user").downField("name").as[String]
// name: Either[DecodingFailure, String] = Right(Ada)

Wyodrębnianie wartości za pomocą as

Po ustawieniu kursora .as[A] próbuje zdekodować wskazaną wartość do typu A.

Zwraca Either[DecodingFailure, A], więc niezgodność typu jest zgłaszana jako wartość, a nie wyjątek.

val json = parse("{\"age\": 36}").toOption.get
val age = json.hcursor.downField("age").as[Int]
println(age)  // Right(36)

parse a decode

Użyj parse, gdy chcesz ręcznie sprawdzać surowe drzewo Json.

Użyj decode[A], gdy chcesz przejść bezpośrednio od String do typowanej wartości A w jednym kroku. Ta funkcja łączy analizowanie i dekodowanie.

import io.circe.parser.decode

val n: Either[io.circe.Error, Int] =
  decode[Int]("42")
println(n)  // Right(42)

Pola opcjonalne

Rzeczywisty JSON często nie zawiera niektórych kluczy. Metoda kursora get[A] wywołana dla wskazanego pola kończy się niepowodzeniem, jeśli tego pola brakuje, natomiast getOrElse dostarcza wartość domyślną.

Dekodowanie do Option[A] traktuje brakujące lub nullowe pole jako None.

val json = parse("{\"name\": \"Ada\"}").toOption.get
val nick = json.hcursor.get[Option[String]]("nickname")
println(nick)  // Right(None)

Analizowanie tablic

Możesz bezpośrednio zdekodować tablicę JSON do kolekcji Scali, żądając typu List[A] lub Vector[A].

Circe mapuje każdy element i natychmiast kończy działanie z DecodingFailure, jeśli którykolwiek element ma nieprawidłowy typ.

import io.circe.parser.decode

val xs = decode[List[Int]]("[1, 2, 3]")
println(xs)  // Right(List(1, 2, 3))

Czytelne formatowanie

Dowolna wartość Json może zostać ponownie zapisana jako tekst za pomocą .noSpaces dla zwartego wyniku lub .spaces2 dla wyniku z wcięciami.

Pozwala to zachować dane po przejściu przez analizowanie i jest przydatne podczas logowania lub debugowania.

val json = parse("{\"a\":1,\"b\":2}").toOption.get
println(json.noSpaces)
println(json.spaces2)

Szybki test

Sprawdź, czy rozumiesz analizowanie za pomocą Circe.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Nauczyłeś się zamieniać tekst JSON na model Circe. parse zwraca Either[ParsingFailure, Json], a decode[A] przechodzi bezpośrednio do typowanej wartości.

HCursor nawiguje za pomocą downField, a .as[A] wyodrębnia typowane wartości. Błędy są wartościami, a nie wyjątkami.

Bezpłatny start

Ucz się Scala dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 143

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Parsowanie JSON” jest bezpłatna?

Tak — pełny tekst „Parsowanie JSON” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Parsowanie JSON”?

Przekształci Pan/Pani tekst w wartości JSON. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Parsowanie JSON”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming