JSON_encode PHP: transformando um valor em formato JSON

JSON é uma das principais estruturas de dados que temos disponíveis para trabalhar com Sistemas Web. Como características principais, apresenta uma alta velocidade de processamento e um tamanho consideravelmente pequeno para armazenamento. A função JSON_encode, do PHP, trabalha exclusivamente manipulando essas estruturas.

Muitas vezes, pessoas que almejam desenvolver sistemas sólidos e online, têm alguns problemas para entender o funcionamento dessa função. Sendo assim, acabam um pouco perdidas sobre como aplicá-las em arrays e objetos denotados em PHP.

Como você verá, isso é facilmente resolvido com explorações detalhadas e exemplos práticos de aplicação. Por isso, no decorrer de nosso guia, exploraremos os pontos principais que qualquer pessoa programadora precisa saber sobre essa função.

Veremos vários exemplos e passaremos brevemente sobre outra função, sendo quase complementar ao JSON_encode: o JSON_decode. Para um maior sucesso de seu aprendizado, dividimos o tema nas seguintes partes:

Então, prepare-se para mais uma exploração do mundo do desenvolvimento, neste guia! Bons estudos!

O que é a função JSON_encode PHP e para que serve?

JSON_encode é uma função nativa da linguagem de programação PHP. Com ela, somos capazes de transformar valores para o formato JSON, muito utilizado como uma versão leve de para armazenamento de arquivos para troca e processamento de dados entre Sistemas Web.

Em outras palavras, a função do JSON_encode é retornar a uma representação alternativa dos valores armazenados — objetos em PHP serão retornados objetos JSON. A implementação ocorreu a partir da versão 5.2 do PHP.

Para ajudar mais no entendimento, trazemos, a seguir, dois exemplos bem simples sobre como podemos utilizar essa função. Confira!

a) String Arrays para JSON

<?php
$array = array('a' => 0, 'b' => 1, 'c' => 2);
$array2 = array('a' => '0', 'b' => '1', 'c' => '2');

echo json_encode($array);
echo json_encode($array2);

$objetojson = array("Site" => "tribe.com","Tipo" => "Programacao", "Nota" => 10);
 
echo json_encode($objetojson);
?>

b) Objeto PHP para JSON

<?php

$array = [
    'nome' => 'Carlos Joaquim',
    'sobrenome' => 'da Silva',
    'ativoSim' => true,
    'ocupacao' => ['ferramenteiro', 'artesao'],
];

echo json_encode($array);

?>

Como vemos, os códigos acima usam as variáveis para armazenar arrays contendo valores de vários tipos. Em seguida, a função json_encode é executada, e cada um dos códigos mostra os seguintes resultados em nosso console, respectivamente:

{"a":0,"b":1,"c":2} {"a":"0","b":"1","c":"2"}
{"Site":"tribe.com","Tipo":"Programacao","Nota":10}

{

"nome":"Carlos Joaquim",
"sobrenome":"da Silva",
"ativoSim":true,
    "ocupacao":[
        "ferramenteiro",
        "artesao"]
}

Qual a sintaxe do JSON_encode PHP?

Pode parecer complicado à primeira vista, mas a sintaxe do JSON_encode não é tão difícil quanto parece. Como você já deve ter percebido, com o exemplo, que para converter os valores para o JSON, escrevemos json_encode e, abrindo parênteses, acrescentamos o valor que queremos retornar como JSON, podendo ser de qualquer tipo, exceto “resource”:

json_encode ($valor(mixed), $opções(int) = 0, $profundidade(int) = 1): string

Lembrando que todos os códigos em PHP devem ser expressos sempre em código UTF-8. Os arrays não aceitam caracteres especiais, como acentos ou cedilha — você poderá ter problemas, caso decida utilizá-los, principalmente, em relação à formatação durante a saída de seus códigos. Veremos detalhes sobre isso, mais adiante.

Quais os parâmetros do JSON_encode PHP?

Vamos abordar, a seguir, os parâmetros value, options e depth, para que você tenha uma melhor compreensão.

Value 

O parâmetro value — ou valor, se traduzido — pode ser especificado pelos seguintes tipos:

  • arrays;
  • booleanos;
  • float;
  • integers;
  • objects;
  • strings;
  • null.

O último tipo, “null”, apenas pode ser utilizado se for parte de um array (ou objeto). Do contrário, seu programa retornará um erro. Alguns detalhes do JSON_encode apenas foram implementados em versões mais recentes do PHP — então, é bom saber que você poderá experimentar alguns problemas com arquivos JSON mais antigos, com valores escalares e o já mencionado “null”.

Options

O segundo parâmetro que pode ser utilizado no JSON_encode é o options, ou opções, em português. São constantes em PHP pré-definidas e que alteram o comportamento da função em alguns detalhes. Falaremos mais sobre elas, um pouco mais à frente, neste nosso guia!

Depth

O parâmetro depth (ou profundidade) estabelece um limite para o array que está sendo processado. Na Ciência da Computação, definimos como profundidade de um array pela quantidade de valores nichados. Veja esse exemplo:

 $array = [
    'nome' => 'Carlos Joaquim',
    'sobrenome' => 'da Silva',
    'ativoSim' => true,
    'ocupacao' => ['ferramenteiro', 'artesao'],
];

Aqui, temos um array de profundidade 1. Por sua vez, um array de profundidade 2 é representado da seguinte maneira:

array(
    array(
        ‘be’
    ),
    array(
        ‘trybe’
    ),
    array(
        ‘voce tambem’
    )
)

O valor máximo que podemos colocar para esse parâmetro é de 512 — a função retornará ‘false’, caso seja maior que isso. Esse parâmetro é bastante útil quando nosso sistema trabalha com entrada de dados um pouco imprevisíveis. Assim, limitamos uma quantidade máxima para não termos maiores problemas.

JSON_encode PHP vs JSON_decode PHP: quais as diferenças?

Não há surpresas quanto às diferenças e semelhanças entre essas duas funções. O JSON_decode faz exatamente o processo avesso do JSON_encode — ele realiza a conversão de um arquivo ou dado estruturado em um JSON para um objeto em PHP.

<?php
$json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

echo var_dump(json_decode($json));

?>

Como esperado, o resultado na saída de nosso console será essa:

object(stdClass)#1 (5) { ["a"]=> int(1) ["b"]=> int(2) ["c"]=> int(3) ["d"]=> int(4) ["e"]=> int(5) } 

Veja, a seguir, outro exemplo de uso de JSON_decode:

<?php
$json = '{"Site":"tribe.com","Tipo":"Programacao","Nota":10}
';

echo var_dump(json_decode($json));

?>

Como você deve se lembrar, esse é o mesmo código que usamos para o JSON_encode, no início de nosso material. A saída será um objeto PHP, e será assim:

object(stdClass)#1 (3) { ["Site"]=> string(9) "tribe.com" ["Tipo"]=> string(11) "Programacao" ["Nota"]=> int(10) }

Você conhece os argumentos do JSON_encode PHP?

Entenda os principais argumentos, a partir de agora!

JSON_FORCE_OBJECT

Basicamente, o argumento JSON_FORCE_OBJECT “força” que a função crie um objeto, e não um array. Veja o exemplo que trazemos:

<?php
$array = ['Ana', 32, true, ['Rosa', 'Azul']];

//imprimindo o array normalmente:
echo json_encode($array);

//forçando a impressão do array como um objeto:
echo json_encode($array, JSON_FORCE_OBJECT);

?>

A saída para o código será:

["Ana",32,true,["Rosa","Azul"]]
{"0":"Ana","1":32,"2":true,"3":{"0":"Rosa","1":"Azul"}}

JSON_UNESCAPED_UNICODE

Lembra-se de quando, no início do material, falamos que as versões mais antigas de JSON podem ter problemas ao serem processadas pela função JSON_encode? Pois bem, existem parâmetros que podem ajudar muito na resolução dessas situações, quando aparecem.

A primeira delas que citaremos é o JSON_UNESCAPED_UNICODE. Seu funcionamento atua na reversão desses comportamentos de versões mais antigas da linguagem — se estamos, por exemplo, trabalhando com operações entre sistemas PHP e JavaScript, usaremos esses parâmetros para adequar nosso arquivo JSON na linguagem alvo:

<?php

$array = ["l"=>"àrárá", "p"=>"requiém"];
echo json_encode($array, JSON_UNESCAPED_UNICODE);

?>

A saída será:

{"l":"àrárá","p":"requiém"}

Em vez de:

{"l":"\u00e0r\u00e1r\u00e1","p":"requi\u00e9m"}

JSON_PRETTY_PRINT

Outra maneira de modificar a saída de nosso JSON é o JSON_PRETTY_PRINT. Ele retorna o JSON de uma maneira mais legível para leitura pelas pessoas:

<?php
$array = [
    'nome' => 'Carlos Joaquim',
    'sobrenome' => 'da Silva',
    'ativoSim' => true,
    'ocupacao' => ['ferramenteiro', 'artesao'],
];

$array2 = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];

echo json_encode($array);

echo json_encode($array2, JSON_PRETTY_PRINT);

echo json_encode($array, JSON_PRETTY_PRINT);

?>

A saída retornará:

{"nome":"Carlos Joaquim","sobrenome":"da Silva","ativoSim":true,"ocupacao":["ferramenteiro","artesao"]}

{ 
"a": 1, 
"b": 2, 
"c": 3, 
"d": 4 }

{ 

"nome": "Carlos Joaquim", 
"sobrenome": "da Silva", 
"ativoSim": true, 
	"ocupacao": [ 
	"ferramenteiro", 
	"artesao" 
	] 
}

JSON_NUMERIC_CHECK

Realiza uma checagem nos dados e os transforma em inteiros:

<?php
$array = ['234000052', 23000000452];

echo json_encode($array, JSON_NUMERIC_CHECK);

echo json_encode($array);

?>

A resposta será essa:

[234000052,23000000452]
["234000052",23000000452]

Repare que, na segunda saída, o primeiro componente, apesar de ser um número, é retornado como uma string, o que não ocorre na primeira, com o uso do parâmetro JSON_NUMERIC_CHECK.

JSON_PARTIAL_OUTPUT_ON_ERROR

Esse parâmetro possibilita que o código seja executado mesmo com problemas durante o processamento:

<?php
$objeto = oabrir("php-teste.txt", "r");
$array = ["file"=>$objeto, "name"=>"php-teste.txt"];

echo json_encode($array, JSON_PARTIAL_OUTPUT_ON_ERROR);
?>

JSON_PRESERVE_ZERO_FRACTION

Assegura que os números fracionários continuem fracionários depois da transformação, confira:

<?php
$array = [5.0, 5.5, 7.8899, 999.9, 7.999999999999999999];

echo json_encode($array, JSON_PRESERVE_ZERO_FRACTION);
?>

Essas são os principais argumentos que podemos utilizar com a função JSON_encode. Durante o desenvolvimento de aplicações em PHP, certamente, você poderá se deparar com outras para resolver problemas ainda mais específicos. Por ora, essas já são mais que necessárias para lidarmos com essas funções para sistemas mais básicos.

Como usar JSON_encode PHP, na prática? Veja 4 exemplos

Agora que já vimos todos os aspectos mais importantes da função PHP JSON_encode, que tal partirmos para mais exemplos práticos e acompanharmos ainda mais de perto alguns detalhes? Prepare a IDE, e mãos à obra!

1. Miscelânea de exemplos

Nesse exemplo, aplicamos alguns dos argumentos que exploramos um pouco mais acima em nosso guia. Confira as diferenças a cada linha que o comando “echo” imprime em seu terminal:

<?php
$a = array('<be>',"'trybe'",'"escola"','Usando cedilha: ç', "\xc3\xa9");

echo "normal_encode: ",  json_encode($a), "\n";
echo "Unicode: ", json_encode($a, JSON_UNESCAPED_UNICODE), "\n";

$b = array();

echo "Um array vazio retornado como um array: ", json_encode($b), "\n";
echo "Array vazio retorna como objeto: ", json_encode($b, JSON_FORCE_OBJECT), "\n\n";

$c = array(array(0,1,2,3,4,5));

echo "Array não-associativo como array: ", json_encode($c), "\n";
echo "Array não-associativo como objeto: ", json_encode($c, JSON_FORCE_OBJECT), "\n\n";

$d = array('escola' => 'be', 'trybe' => 'inscreva-se');

echo "Arrays associativos sempre retornam objetos: ", json_encode($d), "\n";
echo "Arrays associativos sempre retornam objetos, 2:  ", json_encode($d, JSON_FORCE_OBJECT), "\n\n";

A saída que teremos para esse código será a seguinte:

normal_encode: ["","'trybe'","\"escola\"","Usando cedilha: \u00e7","\u00e9"] 

Unicode: ["","'trybe'","\"escola\"","Usando cedilha: ç","é"] 

Um array vazio retornado como um array: [] 

Array vazio retorna como objeto: {} 

Array não-associativo como array: [[0,1,2,3,4,5]] 

Array não-associativo como objeto: 
{
"0":
	{
	"0":0,
	"1":1,
	"2":2,
	"3":3,
	"4":4,
	"5":5
	}
} 

Arrays associativos sempre retornam objetos: 
	{
	"escola":"be",
	"trybe":"inscreva-se"
	} 

Arrays associativos sempre retornam objetos, 2: 
	{
	"escola":"be",
	"trybe":
	"inscreva-se"
	} 

Vale, aqui, uma observação: os arrays associativos têm seus pares chave-valor ordenados, enquanto os arrays não-associativos, não. Veremos mais um exemplo sobre esse assunto, mais à frente, em nosso guia!

2. Acessando valores com JSON_encode e JSON_decode

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Acessando um valor JSON em PHP!</title>
</head>
<body>
 
<?php
// Relacionando um JSON com uma variável PHP:
$objetojson = '{"Suco":2,"Cerveja":8,"Pastel":6,"Refrigerante":90}';
 
// Decoding JSON:
$arr = json_decode($objetojson, true);
 
// Acessando os valores:
echo $arr["Suco"] . "<br>";  
echo $arr["Cerveja"] . "<br>";  
echo $arr["Pastel"]  . "<br>";  
echo $arr["Refrigerante"] . "<br>";  
 
echo "<hr>";
 
// decoding:
$obj = json_decode($objetojson);
 
// acessando os valores do objeto retornado:
echo $obj->Suco . "<br>";  
echo $obj->Cerveja . "<br>";  
echo $obj->Pastel  . "<br>";  
echo $obj->Refrigerante . "<br>";  
?>
 
</body>
</html>

A saída deverá retornar algo parecido com isso:

2
8
6
90
--------
6
8
2
90

3. JSON_PRESERVE_ZERO_FRACTION — usando um parâmetro

Aqui, usaremos o parâmetro JSON_PRESERVE_ZERO_FRACTION da função JSON_encode para manter o zero em números fracionados. Confira, a seguir, um código de exemplo:

<?php
var_dump(json_encode(12.0, JSON_PRESERVE_ZERO_FRACTION));
var_dump(json_encode(12.0));
?>
A saída deverá ser a seguinte, para esse código:

string(4) "12.0" string(2) "12"

4. Arrays sequenciais e não-sequenciais

A seguir, você poderá conferir um exemplo de código operando com array diferentes, sequenciais ou não. Perceba, na saída, o modelo de tratamento para cada um deles:

<?php
echo "Arrays Sequenciais são assim:".PHP_EOL;
$sequential = array("um", "dois", "três", "mil");
var_dump(
 $sequential,
 json_encode($sequential)
);

echo PHP_EOL."Já Arrays Não-Squenciais, são assim:".PHP_EOL;
$nonsequential = array(1=>"um", 2=>"dois", 3=>"três", 4=>"quatro");
var_dump(
 $nonsequential,
 json_encode($nonsequential)
);

echo PHP_EOL."Array Sequenciais com uma chave vazia ficam dessa maneira: ".PHP_EOL;
unset($sequential[1]);
var_dump(
 $sequential,
 json_encode($sequential)
);
?>

A saída deverá ser algo bem parecido com isso:

Arrays Sequenciais são assim:
array(4) {
  [0]=>
  string(2) "um"
  [1]=>
  string(4) "dois"
  [2]=>
  string(5) "três"
  [3]=>
  string(3) "mil"
}
string(31) "["um","dois","tr\u00eas","mil"]"

Já Arrays Não-Squenciais, são assim:
array(4) {
  [1]=>
  string(2) "um"
  [2]=>
  string(4) "dois"
  [3]=>
  string(5) "três"
  [4]=>
  string(6) "quatro"
}
string(50) "{"1":"um","2":"dois","3":"tr\u00eas","4":"quatro"}"

Array Sequenciais com uma chave vazia ficam dessa maneira: 
array(3) {
  [0]=>
  string(2) "um"
  [2]=>
  string(5) "três"
  [3]=>
  string(3) "mil"
}
string(36) "{"0":"um","2":"tr\u00eas","3":"mil"}"

Viu só como não é tão complicado quanto parecia? Entender esses conceitos deixará você mais à vontade na hora de desenvolver um novo sistema em PHP. Em especial, quando houver a necessidade de compartilhamento de arquivos JSON entre vários sistemas — o JSON._encode e o JSON_decode ajudarão muito, tenha certeza disso!

Que tal se aprofundar ainda mais em programação e entrar de cabeça no mercado de desenvolvimento? Faça a inscrição em nosso processo seletivo — acesse nosso curso introdutório gratuito de JavaScript e tire todas as suas dúvidas em nossa comunidade do Slack. Não perca tempo: entre em contato com a Trybe e saiba mais sobre como proceder!

Nascido na terra distante e quente de Teresina - PI em 1986, é quase Bacharel em Sistemas de Informação e trabalha com Desenvolvimento de Software desde 2007. Começou sua carreira na linguagem PHP e depois, em 2009, mudou para Ruby, na qual teve a felicidade de trabalhar no projeto de tradução da documentação para português (do Brasil) do framework Ruby on Rails. Já trabalhou em empresas como Jus Navigandi, e Enjoei, marketplace. Além de ter lidado com as linguagens Ruby e GoLang (2013-2016), e por fim impactou mais de 2 milhões de estudantes em todo o Brasil no AppProva, com as linguagens Ruby, PHP, JavaScript, GoLang e Elixir. Atualmente na Trybe é responsável pelo time de tecnologia de Experiência de Estudantes.