Principais operações de E/S

Artigo
09/26/2024

Além de fornecer ferramentas para ler arquivos de dados espaciais, o módulo de E/S espacial expõe as principais bibliotecas subjacentes para ler e escrever XML e dados delimitados de forma rápida e eficiente.

O atlas.io.core namespace contém duas classes de baixo nível que podem ler e gravar rapidamente dados CSV e XML. Essas classes base alimentam os leitores e gravadores de dados espaciais no módulo de E/S espacial. Sinta-se à vontade para usá-los para adicionar mais suporte de leitura e gravação para arquivos CSV ou XML.

Ler ficheiros delimitados

A atlas.io.core.CsvReader classe lê cadeias de caracteres que contêm conjuntos de dados delimitados. Esta classe fornece dois métodos para ler dados:

A read função lê o conjunto de dados completo e retorna uma matriz bidimensional de cadeias de caracteres que representam todas as células do conjunto de dados delimitado.
A getNextRow função lê cada linha de texto em um conjunto de dados delimitado e retorna uma matriz de cadeia de caracteres que representa todas as células nessa linha do conjunto de dados. O usuário pode processar a linha e descartar qualquer memória desnecessária dessa linha antes de processar a próxima linha. Assim, a função é mais eficiente em termos de memória.

Por padrão, o leitor usa o caractere de vírgula como delimitador. No entanto, o delimitador pode ser alterado para qualquer caractere único ou definido como 'auto'. Quando definido como 'auto', o leitor analisa a primeira linha de texto na cadeia de caracteres. Em seguida, ele seleciona o caractere mais comum da tabela a seguir para usar como delimitador.

Delimitador	Caráter
Comma	`,`
Separador	`\t`
Tubo	`\|`

Este leitor também suporta qualificadores de texto que são usados para manipular células que contêm o caractere delimitador. O caractere de aspas ('"') é o qualificador de texto padrão, mas pode ser alterado para qualquer caractere único.

Escrever arquivos delimitados

O atlas.io.core.CsvWriter grava uma matriz de objetos como uma cadeia de caracteres delimitada. Qualquer caractere único pode ser usado como um delimitador ou um qualificador de texto. O delimitador padrão é vírgula (',') e o qualificador de texto padrão é o caractere aspas ('"').

Siga as etapas para usar essa classe:

Crie uma instância da classe e, opcionalmente, defina um delimitador personalizado ou qualificador de texto.
Escreva dados na classe usando a write função ou a writeRow função. Para a write função, passe uma matriz bidimensional de objetos que representam várias linhas e células. Para usar a writeRow função, passe uma matriz de objetos que representam uma linha de dados com várias colunas.
Chame a toString função para recuperar a cadeia de caracteres delimitada.
Opcionalmente, chame o clear método para tornar o gravador reutilizável e reduza sua alocação de recursos ou chame o delete método para descartar a instância do gravador.

Nota

O número de colunas escritas será limitado ao número de células na primeira linha dos dados passados ao gravador.

Ler arquivos XML

A atlas.io.core.SimpleXmlReader classe é mais rápida na análise de arquivos XML do que DOMParsero . No entanto, a atlas.io.core.SimpleXmlReader classe requer arquivos XML para ser bem formatado. Arquivos XML que não estão bem formatados, por exemplo, tags de fechamento ausentes, podem resultar em um erro.

O código a seguir demonstra como usar a SimpleXmlReader classe para analisar uma cadeia de caracteres XML em um objeto JSON e serializá-lo em um formato desejado.

//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.
        }
    }
}

Escrever arquivos XML

A atlas.io.core.SimpleXmlWriter classe escreve XML bem formatado de forma eficiente em termos de memória.

O código a seguir demonstra como usar a SimpleXmlWriter classe para gerar uma cadeia de caracteres XML bem formatada.

//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();

O XML gerado a partir do código acima seria semelhante ao seguinte.

<?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>