Grundläggande I/O-åtgärder

Artikel
09/26/2024

Förutom att tillhandahålla verktyg för att läsa rumsliga datafiler exponerar den rumsliga I/O-modulen underliggande kärnbibliotek för att läsa och skriva XML och avgränsade data snabbt och effektivt.

Namnområdet atlas.io.core innehåller två lågnivåklasser som snabbt kan läsa och skriva CSV- och XML-data. Dessa basklasser driver de rumsliga dataläsarna och författarna i modulen Spatial IO. Använd dem gärna för att lägga till mer läs- och skrivstöd för CSV- eller XML-filer.

Läsa avgränsade filer

Klassen atlas.io.core.CsvReader läser strängar som innehåller avgränsade datauppsättningar. Den här klassen innehåller två metoder för att läsa data:

Funktionen read läser den fullständiga datauppsättningen och returnerar en tvådimensionell matris med strängar som representerar alla celler i den avgränsade datauppsättningen.
Funktionen getNextRow läser varje textrad i en avgränsad datauppsättning och returnerar en strängmatris som representerar alla celler i den datamängden. Användaren kan bearbeta raden och ta bort allt minne som inte behövs från den raden innan nästa rad bearbetas. Funktionen är därför mer minneseffektiv.

Som standard använder läsaren kommatecknet som avgränsare. Avgränsare kan dock ändras till ett enskilt tecken eller ställas in på 'auto'. När den är inställd 'auto'på analyserar läsaren den första textraden i strängen. Sedan väljer den det vanligaste tecknet i följande tabell som ska användas som avgränsare.

Delimiter	Tecken
Comma	`,`
Tabb	`\t`
Pipa	`\|`

Den här läsaren stöder även textkvalificerare som används för att hantera celler som innehåller avgränsarens tecken. Citattecknet ('"') är standardtextkvalificeraren, men det kan ändras till ett enskilt tecken.

Skriva avgränsade filer

Skriver atlas.io.core.CsvWriter en matris med objekt som en avgränsad sträng. Alla enskilda tecken kan användas som avgränsare eller textkvalificerare. Standardavgränsaren är kommatecken (',') och standardtextkvalificeraren är citattecknet ('"').

Följ stegen för att använda den här klassen:

Skapa en instans av klassen och ange en anpassad avgränsare eller textkval.
Skriv data till klassen med hjälp av write funktionen eller writeRow funktionen. För funktionen write skickar du en tvådimensionell matris med objekt som representerar flera rader och celler. Om du vill använda writeRow funktionen skickar du en matris med objekt som representerar en rad data med flera kolumner.
toString Anropa funktionen för att hämta den avgränsade strängen.
Du kan också anropa clear metoden för att göra skrivaren återanvändbar och minska resursallokeringen, eller anropa delete metoden för att ta bort skrivarinstansen.

Kommentar

Antalet kolumner som skrivs begränsas till antalet celler i den första raden av data som skickas till skrivaren.

Läsa XML-filer

Klassen atlas.io.core.SimpleXmlReader är snabbare vid parsning av XML-filer än DOMParser. Klassen kräver dock atlas.io.core.SimpleXmlReader att XML-filer är väl formaterade. XML-filer som inte är väl formaterade, till exempel saknade avslutande taggar, kan resultera i ett fel.

Följande kod visar hur du använder SimpleXmlReader klassen för att parsa en XML-sträng i ett JSON-objekt och serialisera den till ett önskat format.

//Create an instance of the SimpleXmlReader and parse an XML string into a JSON object.
var xmlDoc = new atlas.io.core.SimpleXmlReader().parse(xmlStringToParse);

//Verify that the root XML tag name of the document is the file type your code is designed to parse.
if (xmlDoc && xmlDoc.root && xmlDoc.root.tagName && xmlDoc.root.tagName === '<Your desired root XML tag name>') {

    var node = xmlDoc.root;

    //Loop through the child node tree to navigate through the parsed XML object.
    for (var i = 0, len = node.childNodes.length; i < len; i++) {
        childNode = node.childNodes[i];

        switch (childNode.tagName) {
            //Look for tag names, parse and serialized as desired.
        }
    }
}

Skriva XML-filer

Klassen atlas.io.core.SimpleXmlWriter skriver välformaterad XML på ett minneseffektivt sätt.

Följande kod visar hur du använder SimpleXmlWriter klassen för att generera en välformaterad XML-sträng.

//Create an instance of the SimpleXmlWriter class.
var writer = new atlas.io.core.SimpleXmlWriter();

//Start writing the document. All write functions return a reference to the writer, making it easy to chain the function calls to reduce the code size.
writer.writeStartDocument(true)
    //Specify the root XML tag name, in this case 'root'
    .writeStartElement('root', {
        //Attributes to add to the root XML tag.
        'version': '1.0',
        'xmlns': 'http://www.example.com',
         //Example of a namespace.
        'xmlns:abc': 'http://www.example.com/abc'
    });

//Start writing an element that has the namespace abc and add other XML elements as children.
writer.writeStartElement('abc:parent');

//Write a simple XML element like <title>Azure Maps is awesome!</title>
writer.writeElement('title', 'Azure Maps is awesome!');

//Close the element that we have been writing children to.
writer.writeEndElement();

//Finish writing the document by closing the root tag and the document.
writer.writeEndElement().writeEndDocument();

//Get the generated XML string from the writer.
var xmlString = writer.toString();

Den genererade XML-koden från ovanstående kod skulle se ut så här.

<?xml version="1.0" encoding="UTF-8"?>
<root version="1.0" xmlns="http://www.example.com" xmlns:abc="http://www.example.com/abc">
    <abc:parent>
        <title>Azure Maps is awesome!</title>
    </abc:parent>
</root>