Parsing sa Mobile Apps: Esensya, Mga Format ng Data at Proseso

Ano ang parsing?

Parsing (syntactic analysis) — ang proseso ng pag-convert ng sequence ng mga character sa structured na representasyon na angkop para sa programmatic processing. Sa konteksto ng mobile development, ang parsing ay tumutukoy sa pagsusuri ng mga server response, configuration file, local cache at resource file. Bawat format ay nangangailangan ng sariling approach: JSON — magaan at naka-build sa SDK, XML — mahigpit na may XSD schema validation, CSV — minimalist para sa tabular data, Protobuf — binary na may matibay na schema.

Mga yugto ng syntactic analysis

Bawat parser, kahit anong format, ay dumadaan sa tatlong yugto. Lexical analysis ay hinahati ang raw text sa mga token: keys, strings, numbers, separators at comments. Syntactic analysis ay sinusuri ang correctness ng grammar — balance ng brackets sa JSON, correctness ng nesting ng tags sa XML. Pagbuo ng output structure ay bumubuo ng object representation: JSONObject, Map, o token stream para sa karagdagang processing. Ayon sa Apple (2026), ang built-in na Foundation parser sa iOS ay gumagamit ng lazy analysis — vina-validate lang ang simula ng JSON, nakakatipid ng resources.

Manual parsing vs automatic libraries

Manual parsing (JSONSerialization, XmlPullParser) ay nagbibigay ng buong kontrol sa proseso at kapaki-pakinabang para sa hindi standard na format o pangangailangan ng custom validation ng bawat field. Automatic libraries (JSONDecoder, Moshi, kotlinx.serialization) ay pinapabilis ang development, ngunit itinatago ang detalye ng error handling. Ang pagpili ay depende sa requirements: kung ang data structure ay dynamic o hindi alam beforehand — manual parsing ay mas gusto. Kung fixed ang schema — automatic deserialization ay nagbabawas ng code ng 60–70%.

Pagkakaiba ng parsing at deserialization

Parsing — mas malawak na operasyon: maaaring isagawa nang streaming at hindi kinakailangang gumawa ng typed object. Deserialization — espesyal na kaso ng parsing, na ang resulta ay palaging instance ng isang klase na alam beforehand na may konkretong uri ng properties. JSON parser ay naghihiwa ng dokumento sa Map o JsonElement, habang ang deserializer ay ginagawang konkretong object na User, Order o Product ang parehong JSON na may alam na fields at kanilang mga uri.

Streaming parsing — pangunahing bentahe ng parsing kaysa deserialization. XmlPullParser sa Android ay nag-parse ng XML habang nagbabasa, nang hindi nilo-load ang buong dokumento sa memorya. Ito ay kritikal para sa malalaking API responses, pag-parse ng RSS feed na may daan-daang elemento, o pagproseso ng array ng libu-libong JSON object mula sa server dump. Streaming parser ay nagbabasa ng token bawat token, kumukonsumo ng constant na dami ng memorya kahit anong laki ng dokumento.

Parsing ng JSON sa mobile apps

JSON — dominanteng format ng data exchange. Sa iOS, ang built-in na JSONSerialization ay nag-parse ng JSON sa Any, at JSONDecoder — direkta sa Codable structure. Sa Android, ang standard na org.json ay nagbibigay ng JSONObject at JSONArray para sa manual analysis. Gson at Moshi ay nagdaragdag ng automatic conversion. Ang pagpili sa pagitan ng manual at automatic approach — unang architectural decision ng network layer.

val jsonString = """{"users":[{"id":1,"name":"Alice"}]}"""
val jsonObject = JSONObject(jsonString)
val usersArray = jsonObject.getJSONArray("users")

for (i in 0 until usersArray.length()) {
    val item = usersArray.getJSONObject(i)
    val id = item.getInt("id")
    val name = item.getString("name")
    // pagproseso ng user
}

Manual parsing sa pamamagitan ng org.json ay kapaki-pakinabang kapag ang structure ng response ay hindi alam beforehand o malaki ang pagkakaiba-iba. Ang approach na ito ay nagbibigay ng buong kontrol sa error handling at nullable fields, ngunit nangangailangan ng mas maraming boilerplate code kumpara sa automatic deserialization. Para sa maliliit na proyekto o prototypes ito ay katanggap-tanggap, ngunit sa production ay inirerekomenda ang Moshi o kotlinx.serialization.

JSONReader para sa streaming analysis

JsonReader mula sa library ng Moshi — makapangyarihang tool para sa streaming JSON parsing. Binabasa ang dokumento token bawat token, gamit ang mga method na beginObject, nextName, nextString, nextInt at endObject. Ang approach na ito ay nagpapahintulot sa pagproseso ng mga dokumento ng anumang laki na may constant memory consumption. Ayon sa Google (2026), ang streaming parsing sa pamamagitan ng JsonReader ay 2–3 beses na mas mabilis kaysa pag-load ng buong dokumento sa JsonObject at kumukonsumo ng hanggang 80% na mas kaunting memorya.

val reader = JsonReader(StringReader(json))
reader.beginObject()
while (reader.hasNext()) {
    val name = reader.nextName()
    when (name) {
        "id" -> val id = reader.nextInt()
        "name" -> val name = reader.nextString()
        "email" -> val email = reader.nextString()
        else -> reader.skipValue()
    }
}
reader.endObject()

Ang halimbawa ay nagpapakita ng JsonReader na nag-parse ng JSON nang streaming. Bawat tawag sa nextName() at nextInt() ay gumagalaw ng cursor sa susunod na token. skipValue() ay lumalaktaw sa hindi kinakailangang field nang hindi ita-parse — ito ay lalong kapaki-pakinabang kapag ang JSON ay naglalaman ng 50 field at 3 lang ang kailangan. Resulta — minimal memory consumption at maximum speed.

Parsing ng XML at CSV

XML ay ginagamit pa rin sa mga Android project para sa resources at sa SOAP services ng corporate applications. Sa Android, ang built-in na XmlPullParser ay nagbibigay ng streaming analysis na may minimal memory consumption — hindi naglo-load ng DOM tree, bagkus gumagawa ng START_TAG, TEXT, END_TAG events. iOS ay gumagamit ng XMLParser na may delegate approach: ang mga method na parser(didStartElement:) at parser(foundCharacters:) ay nagpo-process ng mga element nang sequential.

CSV sa mobile development

CSV — pinakasimpleng format para sa export at import ng tabular data. Sa mga mobile app, CSV ay ginagamit para sa pag-export ng reports, pag-load ng mga direktoryo (listahan ng bansa, pera, code) at synchronize ng offline data. Para sa CSV parsing, ang streaming libraries ay angkop: Apache Commons CSV at OpenCSV ay nagpo-process ng file line by line, nag-e-escape ng quotes at commas sa loob ng values. Sa iOS, CSV parsing ay maaaring gawin sa pamamagitan ng delimiter na NSString.components(separatedBy:) na may handling ng edge cases.

class CSVParser: NSObject, XMLParserDelegate {
    private var currentItem: [String: String] = [:]
    private var currentElement: String = ""

    func parser(
        _ parser: XMLParser,
        didStartElement elementName: String,
        namespaceURI: String?,
        qualifiedName qName: String?,
        attributes attributeDict: [String: String]
    ) {
        currentElement = elementName
        if elementName == "item" {
            currentItem = [:]
        }
    }

    func parser(_ parser: XMLParser,
                foundCharacters string: String) {
        currentItem[currentElement] = string
    }
}

Halimbawa ng XMLParser delegate sa iOS para sa pag-parse ng RSS feed. Ang method na didStartElement ay tinatawag sa bawat opening tag, foundCharacters ay nagbabalik ng text content sa pagitan ng tags, didEndElement ay nagtatapos ng elemento. Ang ganitong event-driven architecture ay nagpapahintulot sa pagproseso ng XML ng anumang laki nang hindi nilo-load ang DOM tree sa memorya — kritikal para sa limitadong resources ng mobile devices.

Paghahambing ng CSV libraries para sa Android

Sa Android, ang pagpili ng CSV parser ay depende sa volume ng data. OpenCSV ay sumusuporta sa fluent API, annotations para sa mapping sa POJO at custom separators. Apache Commons CSV — mas mababang level, ngunit mas mabilis sa malalaking file. Para sa simpleng kaso (1–2 column), sapat na ang manual analysis sa pamamagitan ng String.split(",") na may escape handling. Para sa production projects na may malalaking CSV file, inirerekomenda ang OpenCSV.

Protobuf at streaming parsing

Protocol Buffers mula sa Google — binary serialization format, higit sa JSON sa bilis at compactness. Ang Protobuf message ay kumukuha ng 3–6 beses na mas kaunting espasyo kaysa sa katumbas na JSON at na-parse ng 4–10 beses na mas mabilis dahil sa binary format at matibay na schema. Pangunahing disadvantages: kakulangan ng human readability at pangangailangan na gumawa ng code mula sa .proto files sa pamamagitan ng protoc compiler.

Streaming parsing ng Protobuf ay ipinapatupad sa pamamagitan ng CodedInputStream — binabasa ng client ang mga field habang dumarating ang mga ito nang hindi nilo-load ang buong mensahe. Bawat field ay may tag (number + type), at ang parser ay maaaring lumaktaw sa hindi kilalang field. Ayon sa Google (2026), ang streaming analysis ng Protobuf ay kumukonsumo ng hanggang 90% na mas kaunting memorya sa pagproseso ng mga mensahe mula sa 1 MB, na kritikal para sa mobile devices na may limitadong RAM. Protobuf-lite — espesyal na version para sa Android, optimized para sa laki ng generated code.