Operações de E/S básicas

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 gravar XML e dados delimitados de forma rápida e eficiente.

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

Ler arquivos delimitados

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

A função read 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 função getNextRow lê cada linha de texto em um conjunto de dados delimitado e retorna uma matriz de cadeia de caracteres representando todas as células do conjunto de dados delimitado. O usuário pode processar a linha e descartar qualquer memória desnecessária dessa linha antes de processar a linha seguinte. Portanto, 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 o delimitador.

Delimitador	Caractere
Vírgula	`,`
Tab	`\t`
Pipe	`\|`

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

Gravar 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 é a 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.
Grave dados na classe usando a função write ou a função writeRow. Para a função write, passe uma matriz bidimensional de objetos representando várias linhas e células. Para usar a função writeRow, passe uma matriz de objetos representando uma linha de dados com várias colunas.
Chame a função toString para recuperar a cadeia de caracteres delimitada.
Opcionalmente, chame o método clear para tornar o gravador reutilizável e reduzir sua alocação de recursos ou chame o método delete para descartar a instância do gravador.

Observação

O número de colunas gravadas será restrito ao número de células na primeira linha dos dados passados para o gravador.

Ler arquivos XML

A classe atlas.io.core.SimpleXmlReader é mais rápida na análise de arquivos XML do que DOMParser. No entanto, a classe atlas.io.core.SimpleXmlReader requer que os arquivos XML sejam bem formatados. Os arquivos XML que não estiverem bem formatados, por exemplo, sem marcas de fechamento, podem resultar em um erro.

O código a seguir demonstra como usar a classe SimpleXmlReader para analisar uma cadeia de caracteres XML em um objeto JSON e serializá-la 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.
        }
    }
}

Gravar arquivos XML

A classe atlas.io.core.SimpleXmlWriter grava XML bem formatado de maneira eficiente em relação à memória.

O código a seguir demonstra como usar a classe SimpleXmlWriter 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 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>