MessagePack to JSON Converter

Tags

History

MessagePack is an efficient binary serialization format which is similar to JSON but faster and smaller in size. It is just that it is not meant for the human eye.

JavaScript Object Notation (JSON), pronounced as Jason, is the most common data interchange format on the web. Douglas Crockford first released the JSON specification in the early 2000s. It is a simple format that is easier to comprehend than XML. It is also smaller in size because it does not have closing tags. A wide variety of programming languages can parse JSON files. They also support the serialization of data structures to JSON. You can copy JSON text to JavaScript and start using them without any modifications.

Settings Explained

Input Type
The type of the input MessagePack data. The following input formats are supported:-
- Hex
  In Hex mode, the MessagePack bytes are converted to their two digit hex representation. You can include space between the individual bytes, wrap the output & convert the hex characters to uppercase.
```
DD 00 00 00 01 DF 00 00 00 04 A4 6E 61 6D 65 AA 52 6F 62 69 
6E 20 48 6F 6F 64 AA 64 65 70 61 72 74 6D 65 6E 74 A0 A7 6D 
61 6E 61 67 65 72 A0 A6 73 61 6C 61 72 79 CC C8
```
- Base64
  In Base64 mode, the MessagePack bytes are converted to Base64 format.
```
3QAAAAHfAAAABKRuYW1lqlJvYmluIEhvb2SqZGVwYXJ0bWVudKCnbWFuYWdlcqCmc2FsYXJ5zMg=
```
- UInt8 Array
  Here, the output is an array of 8 bit unsigned integers which can be used in programming languages such as JavaScript, Java, C#. You can delimit the numbers by space & wrap the output. Uppercase setting is not available because the output is comprised of digits only and there are no alphabets in the output.
```
[221, 0, 0, 0, 1, 223, 0, 0, 0, 4, 164, 110, 97, 109, 101, 170, 82, 111, 98, 105, 
110, 32, 72, 111, 111, 100, 170, 100, 101, 112, 97, 114, 116, 109, 101, 110, 116, 160, 167, 109, 
97, 110, 97, 103, 101, 114, 160, 166, 115, 97, 108, 97, 114, 121, 204, 200]
```
- Bracketed Binary
  In this format, the binary characters are wrapped in their hex forms inside brackets
```
Ý[0x00][0x00][0x00][0x01]ß[0x00][0x00][0x00][0x04][0xA4]nameªRobin[0x20]Hoodªdepartment[0xA0]
[0xA7]manager[0xA0][0xA6]salaryÌÈ
```
- Escaped Hex
  In this format, the binary characters are prefixed by \x followed by a two character Hex representation of the byte value
```
Ý\x00\x00\x00\x01ß\x00\x00\x00\x04¤nameªRobin Hoodªdepartment §manager ¦salaryÌÈ
```
- Raw
  In this format, the binary characters are converted to ASCII. You may see non printable characters in the output which are hard to comprehend.
Indent
This setting governs whether or not the Output is indented. The indented Output is easier to comprehend. On the other hand, a non-indented output is compact. The smaller size is best for transmission over the network. So, we often minify JSON by removing non-essential whitespace.
- Indentation On
```
{
    "name": "John Doe",
    "age": 69
}
```
- Indentation Off
```
{"name":"John Doe","age":69}
```
Keys In Quotes
A valid JSON must have double quotes around the keys (or property names). Unless the keys include special characters, double quotes are unnecessary when used directly inside JavaScript. Turn off this setting if you want to omit quotes around keys.
- Keys In Quotes On
```
{"name":"John Doe","age":69}
```
- Keys In Quotes Off
```
{name:"John Doe",age:69}
```
Camel Case Property Names
Case of properties is changed using this strategy.
Use this option only when cleaning a JSON structure because changing the keys will cause failures in applications that use this JSON format.
- None
```
No case Change
```
- Lower Case
```
lower case change
```
- Upper Case
```
UPPER CASE CHANGE
```
- Camel Case
```
camelCaseChange
```
- Pascal Case
```
PascalCaseChange
```
- Title Case
```
Title Case Change
```
- Snake Case
```
snake_case_change
```
- Kebab Case
```
kebab-case-change
```
- Sentence Case
```
Sentence case change
```

Expanded Braces

Braces are written on a new line (C# style) when this option is selected. Turning the option off puts the Braces on the same line (Java/JavaScript style).

Expanded Braces On

{
  "name": "John Doe",
  "age": 25,
  "addresses":
  [
    {
      "city": "Phoenix",
      "country": "Arizona"
    },
    {
      "city": "Miami",
      "country": "Florida"
    }
  ]
}

Expanded Braces Off

{
  "name": "John Doe",
  "age": 25,
  "addresses": [
    {
      "city": "Phoenix",
      "country": "Arizona"
    },
    {
      "city": "Miami",
      "country": "Florida"
    }
  ]
}

Format Embedded JSON

When this option is selected, JSON embedded or escaped within string values is processed, expanded & converted to nodes.

Format Embedded JSON On

{
  "name": "John Doe",
  "age": 25,
  "addresses": [
    {
      "city": "Phoenix",
      "country": "Arizona"
    },
    {
      "city": "Miami",
      "country": "Florida"
    }
  ]
}

Format Embedded JSON Off

{
  "name": "John Doe",
  "age": 25,
  "addresses": "[{\"city\":\"Phoenix\",\"country\":\"Arizona\"},{\"city\":\"Miami\",\"country\":\"Florida\"}]"
}

Date Format Handling
Even though there is no standard for representing dates in JSON, two popular formats have emerged. The ISO Date Format is the most widely used. If you are using a .NET stack, quite possibly you are using the Microsoft Date Format.
- ISO Date Format
```
{"systemTime":"2014-01-01T23:28:56.782Z"}
```
- Microsoft Date Format
```
{"systemTime":"\/Date(1388618936782)\/"}
```
Allow Partial Parsing
If selected, even incomplete, corrupt or erroneous message pack data is attempted to be converted. This can be used to diagnose and debug issues with your msgpack data.