译文精选｜JSON 的速度慢得令人难以置信，还有更快的办法吗？

【关于TalkX】

TalkX是一款基于GPT实现的IDE智能开发插件，专注于编程领域，是开发者在日常编码中提高编码效率及质量的辅助工具，TalkX常用的功能包括但不限于：解释代码、中英翻译、性能检查、安全检查、样式检查、优化并改进、提高可读性、清理代码、生成测试用例等。

TalkX建立了全球加速网络，不需要考虑网络环境，响应速度快，界面效果和交互体验更流畅。并为用户提供了OpenAI的密钥，不需要ApiKey，不需要自备账号，不需要魔法。

TalkX产品支持：JetBrains (包括 IntelliJ IDEA、PyCharm、WebStorm、Android Studio)、HBuilder、VS Code、Goland.

Yes, you heard that right! JSON, the ubiquitous format for data interchange in web development, might be slowing down your applications. In a world where speed and responsiveness are paramount, it’s crucial to examine the performance implications of JSON, a technology we often take for granted. In this blog, we’ll dive deep into the reasons why JSON can be a bottleneck in your applications and explore faster alternatives and optimization techniques to keep your apps running at their best.

是的，你没听错！JSON 是网络开发中无处不在的数据交换格式，它可能会降低应用程序的运行速度。在这个速度和响应速度至上的世界里，检查 JSON 的性能影响至关重要，因为我们常常认为这是一种理所当然的技术。在本博客中，我们将深入探讨 JSON 可能成为应用程序瓶颈的原因，并探索更快的替代方法和优化技术，使您的应用程序保持最佳运行状态。

What JSON Is and Why You Should Care?

JSON, short for JavaScript Object Notation, is a lightweight data interchange format that has become the go-to choice for transmitting and storing data in web applications. Its simplicity and human-readable format make it easy for both humans and machines to work with. But why should you care about JSON in the context of your web development projects?

JSON is the glue that holds together the data in your applications. It’s the language in which data is communicated between servers and clients, and it’s the format in which data is stored in databases and configuration files. In essence, JSON plays a pivotal role in modern web development.

Understanding JSON and its nuances is not only a fundamental skill for any web developer but also crucial for optimizing your applications. As we delve deeper into this blog, you’ll discover why JSON can be a double-edged sword when it comes to performance and how this knowledge can make a significant difference in your development journey.

JSON是什么，为什么你应该关注？

JSON 是 JavaScript Object Notation 的缩写，是一种轻量级数据交换格式，已成为网络应用程序中传输和存储数据的首选。它的简单性和人类可读格式使人类和机器都能轻松使用。但是，为什么要在网络开发项目中关注 JSON 呢？

JSON 是连接应用程序中数据的粘合剂。它是服务器和客户端之间进行数据通信的语言，也是数据库和配置文件中存储数据的格式。从本质上讲，JSON 在现代网络开发中起着举足轻重的作用。

了解 JSON 及其细微差别不仅是任何网络开发人员的基本技能，而且对于优化应用程序也至关重要。随着我们对这篇博客的深入研究，您将会发现为什么 JSON 在性能方面是一把双刃剑，以及这些知识如何在您的开发之旅中发挥重要作用。

The popularity of JSON and why people use it…

JSON’s popularity in the world of web development can’t be overstated. It has emerged as the de facto standard for data interchange for several compelling reasons:

1、Human-Readable Format: JSON uses a straightforward, text-based structure that is easy for both developers and non-developers to read and understand. This human-readable format enhances collaboration and simplifies debugging.

2、Language Agnostic: JSON is not tied to any specific programming language. It’s a universal data format that can be parsed and generated by almost all modern programming languages, making it highly versatile.

3、Data Structure Consistency: JSON enforces a consistent structure for data, using key-value pairs, arrays, and nested objects. This consistency makes it predictable and easy to work with in various programming scenarios.

4、Browser Support: JSON is supported natively in web browsers, allowing web applications to communicate with servers seamlessly. This native support has contributed significantly to its adoption in web development.

5、JSON APIs: Many web services and APIs provide data in JSON format by default. This has further cemented JSON’s role as the go-to choice for data interchange in web development.

6、JSON Schema: Developers can use JSON Schema to define and validate the structure of JSON data, adding an extra layer of clarity and reliability to their applications.

Given these advantages, it’s no wonder that developers across the globe rely on JSON for their data interchange needs. However, as we explore deeper into the blog, we’ll uncover the potential performance challenges associated with JSON and how to address them effectively.

JSON 的流行以及人们使用它的原因…

JSON 在网络开发领域的受欢迎程度怎么强调都不为过。它已成为数据交换的事实标准，这有几个令人信服的原因：

1、人性化的可读格式： JSON 使用简单明了、基于文本的结构，便于开发人员和非开发人员阅读和理解。这种人类可读的格式增强了协作，简化了调试。

2、与语言无关： JSON 与任何特定的编程语言无关。它是一种通用的数据格式，几乎所有现代编程语言都能对其进行解析和生成，因此具有很强的通用性。

3、数据结构一致性：JSON使用键值对、数组和嵌套对象来实现数据结构的一致性。这种一致性使其具有可预测性，便于在各种编程场景中使用。

4、浏览器支持： JSON 在网络浏览器中得到原生支持，允许网络应用程序与服务器进行无缝通信。这种本地支持极大地促进了 JSON 在网络开发中的应用。

5、JSON API： 许多网络服务和 API 默认以 JSON 格式提供数据。这进一步巩固了 JSON 在网络开发中作为数据交换首选的地位。

6、JSON 模式： 开发人员可以使用 JSON 模式来定义和验证 JSON 数据的结构，从而为他们的应用程序增加一层额外的清晰度和可靠性。

鉴于这些优势，难怪全球的开发人员都依赖 JSON 来满足他们的数据交换需求。不过，随着我们对该博客的深入探讨，我们将发现与 JSON 相关的潜在性能挑战以及如何有效解决这些挑战。

The Importance of Application Speed and Responsiveness

In today’s fast-paced digital landscape, application speed and responsiveness are non-negotiable. Users expect instant access to information, swift interactions, and seamless experiences across web and mobile applications. This demand for speed is driven by several factors:

1、User Expectations: Users have grown accustomed to lightning-fast responses from their digital interactions. They don’t want to wait for web pages to load or apps to respond. A delay of even a few seconds can lead to frustration and abandonment.

2、Competitive Advantage: Speed can be a significant competitive advantage. Applications that respond quickly tend to attract and retain users more effectively than sluggish alternatives.

3、Search Engine Rankings: Search engines like Google consider page speed as a ranking factor. Faster-loading websites tend to rank higher in search results, leading to increased visibility and traffic.

4、Conversion Rates: E-commerce websites, in particular, are acutely aware of the impact of speed on conversion rates. Faster websites lead to higher conversion rates and, consequently, increased revenue.

5、Mobile Performance: With the proliferation of mobile devices, the need for speed has become even more critical. Mobile users often have limited bandwidth and processing power, making fast app performance a necessity.

应用速度和响应速度的重要性

在当今快节奏的数字环境中，应用程序的速度和响应能力是不容忽视的。用户希望在网络和移动应用程序中即时获取信息、快速交互和无缝体验。对速度的这种要求是由以下几个因素驱动的：

1、用户期望： 用户已习惯于从数字交互中获得闪电般快速的响应。他们不想等待网页加载或应用程序响应。哪怕是几秒钟的延迟，都可能导致沮丧和放弃。

**2、竞争优势：**速度可以成为重要的竞争优势。反应迅速的应用程序往往比反应迟缓的应用程序更能吸引和留住用户。

3、搜索引擎排名：谷歌等搜索引擎将页面速度视为排名因素之一。加载速度更快的网站往往在搜索结果中排名靠前，从而提高知名度和流量。

4、转换率： 电子商务网站尤其清楚速度对转换率的影响。网站速度越快，转化率越高，收入也就越高。

5、移动性能： 随着移动设备的普及，对速度的需求变得更加重要。移动用户的带宽和处理能力往往有限，因此，快速的应用程序性能是必要的。

Is JSON Slowing Down Our Apps?

Now, let’s address the central question: Is JSON slowing down our applications?

JSON, as mentioned earlier, is an immensely popular data interchange format. It’s flexible, easy to use, and widely supported. However, this widespread adoption doesn’t make it immune to performance challenges.

JSON, in certain scenarios, can be a culprit when it comes to slowing down applications. The process of parsing JSON data, especially when dealing with large or complex structures, can consume valuable milliseconds. Additionally, inefficient serialization and deserialization can impact an application’s overall performance.

In the sections that follow, we’ll explore the specific reasons why JSON can be a bottleneck in your applications and, more importantly, how to mitigate these issues. As we go farther ahead, keep in mind that our goal is not to discredit JSON but to understand its limitations and discover strategies for optimizing its performance in the pursuit of faster, more responsive applications.

Why JSON Can Be Slow

JSON, despite its widespread use, isn’t immune to performance challenges. Let’s explore the reasons behind JSON’s potential slowness and understand why it might not always be the speediest choice for data interchange.

1. Parsing Overhead

When JSON data arrives at your application, it must undergo a parsing process to transform it into a usable data structure. Parsing can be relatively slow, especially when dealing with extensive or deeply nested JSON data.

2. Serialization and Deserialization

JSON requires data to be serialized (encoding objects into a string) when sent from a client to a server and deserialized (converted the string back into usable objects) upon reception. These steps can introduce overhead and affect your application’s overall speed.

In the world of microservices architecture, JSON is often used for passing messages between services. However, it’s crucial to recognize that JSON messages require serialization and deserialization, processes that can introduce significant overhead.

In scenarios with numerous microservices communicating constantly, this overhead can add up and potentially slow down your applications to an extent that affects user experience.

The second challenge we faced was that due to the textual nature of JSON, serialization and deserialization latency and throughput were suboptimal.
— LinkedIn

3. String Manipulation

JSON is text-based, relying heavily on string manipulation for operations like concatenation and parsing. String handling can be slower compared to working with binary data.

4. Lack of Data Types

JSON has a limited set of data types (e.g., strings, numbers, booleans). Complex data structures might need less efficient representations, leading to increased memory usage and slower processing.

5. Verbosity

JSON’s human-readable design can result in verbosity. Redundant keys and repetitive structures increase payload size, causing longer data transfer times.

The first challenge is that JSON is a textual format, which tends to be verbose. This results in increased network bandwidth usage and higher latencies, which is less than ideal.
— LinkedIn

6. No Binary Support

JSON lacks native support for binary data. When dealing with binary data, developers often need to encode and decode it into text, which can be less efficient.

7. Deep Nesting

In some scenarios, JSON data can be deeply nested, requiring recursive parsing and traversal. This computational complexity can slow down your application, especially without optimization.

JSON 为什么会变慢

尽管 JSON 被广泛使用，但它也难逃性能挑战。让我们来探究 JSON 可能会变慢的原因，并理解为什么 JSON 并不总是数据交换的最佳选择。

1. 解析开销

JSON 数据到达应用程序后，必须经过解析过程才能转换成可用的数据结构。解析过程可能相对较慢，尤其是在处理大量或深度嵌套的 JSON 数据时。

2. 序列化和反序列化

JSON 要求在从客户端向服务器发送数据时进行序列化（将对象编码为字符串），并在接收数据时进行反序列化（将字符串转换回可用对象）。这些步骤会带来开销并影响应用程序的整体速度。

在微服务架构的世界里，JSON 通常用于在服务之间传递消息。但是，我们必须认识到，JSON 消息需要序列化和反序列化，这些过程会带来巨大的开销。

在有大量微服务不断通信的场景中，这种开销可能会增加，并有可能降低应用程序的运行速度，从而影响用户体验。

我们面临的第二个挑战是，由于 JSON 的文本性质，序列化和反序列化的延迟和吞吐量都不理想。

• LinkedIn

3. 字符串操作

JSON 以文本为基础，在进行连接和解析等操作时主要依赖字符串操作。与处理二进制数据相比，字符串处理速度较慢。

4. 缺乏数据类型

JSON 的数据类型（如字符串、数字、布尔值）非常有限。复杂的数据结构可能需要效率较低的表示方法，从而导致内存使用量增加和处理速度减慢。

5. 冗长

JSON 的人机可读设计可能导致冗长。冗余的键和重复的结构会增加有效载荷的大小，导致数据传输时间延长。

第一个挑战是 JSON 是一种文本格式，往往比较冗长。这导致网络带宽使用量增加，延迟时间延长，效果并不理想。

• LinkedIn

6. 不支持二进制

JSON 缺乏对二进制数据的本地支持。在处理二进制数据时，开发人员通常需要将其编码和解码为文本，这可能会降低效率。

7. 深嵌套

在某些情况下，JSON 数据可能是深嵌套的，需要递归解析和遍历。这种计算复杂性会降低应用程序的运行速度，尤其是在没有优化的情况下。

Alternatives to JSON

While JSON is a versatile data interchange format, its performance limitations in certain scenarios have led to the exploration of faster alternatives. Let’s delve into some of these alternatives and understand when and why you might choose them:

1. Protocol Buffers (protobuf)

Protocol Buffers, often referred to as protobuf, are a binary serialization format developed by Google. They are designed for efficiency, compactness, and speed. Protobuf’s binary nature makes it significantly faster than JSON for serialization and deserialization.

• When to Choose: Consider protobuf when you require high-performance data interchange, especially in microservices architectures, IoT applications, or scenarios with limited network bandwidth.

GitHub：vaishnav-mk/protobuf-example

2. MessagePack

MessagePack is another binary serialization format known for its speed and compactness. It’s designed to be more efficient than JSON while maintaining compatibility with various programming languages.

• When to Choose: MessagePack is a great choice when you need a balance between speed and cross-language compatibility. It’s suitable for real-time applications and situations where data size reduction is crucial.

3. BSON (Binary JSON)

BSON, or Binary JSON, is a binary-encoded format derived from JSON. It retains JSON’s flexibility while improving performance through binary encoding. BSON is commonly used in databases like MongoDB.

• When to Choose: If you’re working with MongoDB or need a format that bridges the gap between JSON and binary efficiency, BSON is a valuable option.

4. Apache Avro

Apache Avro is a data serialization framework that focuses on providing a compact binary format. It’s schema-based, allowing for efficient data encoding and decoding.

• When to Choose: Avro is suitable for scenarios where schema evolution is important, such as in data storage, and when you need a balance between speed and data structure flexibility.

These alternatives offer varying degrees of performance improvements over JSON, and the choice depends on your specific use case. By considering these alternatives, you can optimize your application’s data interchange processes, ensuring that speed and efficiency are at the forefront of your development efforts.

JSON 的替代品

虽然 JSON 是一种通用的数据交换格式，但由于其在某些情况下的性能限制，人们开始探索更快的替代格式。让我们深入探讨其中的一些替代方案，了解何时以及为何选择它们：

1. 协议缓冲区（protobuf）

协议缓冲区通常被称为 protobuf，是谷歌开发的一种二进制序列化格式。其设计宗旨是高效、紧凑和快速。Protobuf 的二进制特性使其在序列化和反序列化方面的速度明显快于 JSON。

• 何时选择：** 当你需要高性能的数据交换时，尤其是在微服务架构、物联网应用或网络带宽有限的情况下，请考虑使用protobuf。

2. 消息包

MessagePack 是另一种二进制序列化格式，以速度快、结构紧凑而著称。它在保持与各种编程语言兼容的同时，设计得比 JSON 更高效。

• 何时选择：** 当你需要在速度和跨语言兼容性之间取得平衡时，MessagePack 是一个不错的选择。它适用于实时应用和对减少数据大小至关重要的情况。

3. BSON（二进制 JSON）

BSON 或二进制 JSON 是一种从 JSON 衍生出来的二进制编码格式。它保留了 JSON 的灵活性，同时通过二进制编码提高了性能。BSON 常用于 MongoDB 等数据库。

• 何时选择：** 如果你正在使用 MongoDB，或者需要一种格式在 JSON 和二进制效率之间架起一座桥梁，那么 BSON 就是一个很有价值的选择。

4. Apache Avro

Apache Avro 是一个数据序列化框架，主要提供一种紧凑的二进制格式。它基于模式，可实现高效的数据编码和解码。

• 何时选择**： Avro 适用于模式演进非常重要的情况，如数据存储，以及需要在速度和数据结构灵活性之间取得平衡的情况。

与 JSON 相比，这些替代方案提供了不同程度的性能改进，具体选择取决于您的具体使用情况。通过考虑这些替代方案，您可以优化应用程序的数据交换流程，确保将速度和效率放在开发工作的首位。

The Significance of Every Byte: Optimizing Data Formats

In the world of data interchange, where efficiency and speed are paramount, the choice of data format can make a world of difference. This section explores the journey from a simple JSON data representation to more efficient binary formats like Protocol Buffers, MessagePack, BSON, and Avro. We’ll delve into the nuances of each format and demonstrate why every byte matters.

The Beginning: JSON Data

We start our journey with a straightforward JSON data structure. Here’s a snippet of our sample JSON data:

每个字节的意义：优化数据格式

在效率和速度至上的数据交换领域，数据格式的选择会产生天壤之别。本节将探讨从简单的 JSON 数据表示到更高效的二进制格式（如协议缓冲区、MessagePack、BSON 和 Avro）的过程。我们将深入探讨每种格式的细微差别，并展示为什么每个字节都很重要。

开始：JSON 数据

我们从简单明了的 JSON 数据结构开始。下面是我们的 JSON 数据示例片段：

{
  "id": 1,                                 // 14 bytes
  "name": "John Doe",                      // 20 bytes
  "email": "johndoe@example.com",          // 31 bytes
  "age": 30,                               // 9 bytes
  "isSubscribed": true,                    // 13 bytes
  "orders": [                              // 11 bytes
    {                                      // 2 bytes
      "orderId": "A123",                   // 18 bytes
      "totalAmount": 100.50                // 20 bytes
    },                                     // 1 byte
    {                                      // 2 bytes
      "orderId": "B456",                   // 18 bytes
      "totalAmount": 75.25                 // 19 bytes
    }                                      // 1 byte
  ]                                        // 1 byte
}                                          // 1 byte

Total JSON Size: ~139 bytes

While JSON is versatile and easy to work with, it has a drawback — its textual nature. Each character, each whitespace, and every quotation mark matters. In scenarios where data size and transmission speed are critical, these seemingly trivial characters can have a significant impact.

JSON 总大小：~*139 字节

虽然 JSON 用途广泛且易于使用，但它也有一个缺点，那就是它的文本性质。每个字符、每个空格和每个引号都很重要。在数据大小和传输速度至关重要的情况下，这些看似微不足道的字符可能会产生重大影响。

The Efficiency Challenge: Reducing Size with Binary Formats

Now, let’s provide data representations for other formats and compare their sizes:

Protocol Buffers (protobuf):

效率挑战： 使用二进制格式减小数据大小

现在，让我们提供其他格式的数据表示并比较它们的大小：

协议缓冲区（protobuf）

syntax = "proto3";

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
  bool is_subscribed = 5;
  repeated Order orders = 6;

  message Order {
    string order_id = 1;
    float total_amount = 2;
  }
}

0A 0E 4A 6F 68 6E 20 44 6F 65 0C 4A 6F 68 6E 20 44 6F 65 65 78 61 6D 70 6C 65 2E 63 6F 6D 04 21 00 00 00 05 01 12 41 31 32 33 03 42 DC CC CC 3F 05 30 31 31 32 34 34 35 36 25 02 9A 99 99 3F 0D 31 02 42 34 35 36 25 02 9A 99 99 3F

Total Protocol Buffers Size（协议缓冲区总大小）: ~38 bytes

MessagePack（信息包）:

(Note: MessagePack is a binary format, and the representation here is not human-readable.)

（注意：MessagePack 是一种二进制格式，此处的表示法非人工可读。）

Binary Representation（二进制表示） (Hexadecimal)十六进制:

3e0000001069640031000a4a6f686e20446f6502656d61696c006a6f686e646f65406578616d706c652e636f6d1000000022616765001f04370e4940

Total BSON Size: ~43 bytes

Avro:

(Note: Avro uses a schema, so the data is encoded along with schema information.)

(注：Avro 使用模式，因此数据与模式信息一起编码）。

Binary Representation（二进制表示） (Hexadecimal十六进制):

0e120a4a6f686e20446f650c6a6f686e646f65406578616d706c652e636f6d049a999940040a020b4108312e3525312e323538323539

Total Avro Size: ~32 bytes

Now you might be wondering why even though some of these formats output binary, they have varied sizes. Binary formats like Avro, MessagePack, and BSON have different internal structures and encoding mechanisms, which can result in variations in the binary representations even though they ultimately represent the same data. Here’s a brief overview of how these differences arise:

1. Avro:

• Avro uses a schema to encode data, and this schema is typically included in the binary representation.

• Avro’s schema-based encoding allows for efficient data serialization and deserialization by specifying the data’s structure in advance.

• Avro’s binary format is designed to be self-descriptive, meaning that the schema information is included in the encoded data. This self-descriptive nature allows Avro to maintain compatibility between different versions of data schemas.

2. MessagePack:

MessagePack is a binary serialization format that directly encodes the data, without including schema information.

It uses a compact binary representation with variable-length integers and variable-length strings to minimize space usage.

MessagePack does not include schema information, making it more suitable for scenarios where the schema is known ahead of time and shared between sender and receiver.

3. BSON:

BSON is a binary encoding of JSON data and includes type information for each value.

BSON’s design is closely tied to JSON, but it adds binary data types, such as date and binary data, which JSON lacks.

Like MessagePack, BSON does not include schema information.

These differences in design and encoding result in variations in the binary representations:

Avro includes schema information and is self-descriptive, which contributes to a slightly larger binary size but provides schema compatibility.

MessagePack is highly compact due to its variable-length encoding but lacks schema information, making it suitable for scenarios with known schemas.

BSON is closely related to JSON and includes type information, which can increase the size compared to purely binary formats like MessagePack.

In summary, these differences arise from the design goals and features of each format. Avro prioritizes schema compatibility, MessagePack focuses on compactness, and BSON maintains JSON-like structures with added binary types. The choice of format depends on your specific use case and requirements, such as schema compatibility, data size, and ease of use.

现在你可能想知道，为什么有些格式输出的是二进制，但它们的大小却各不相同。Avro、MessagePack 和 BSON 等二进制格式具有不同的内部结构和编码机制，这可能导致二进制表示法的差异，即使它们最终表示的是相同的数据。下面简要介绍一下这些差异是如何产生的：

1. Avro：

• Avro 使用模式对数据进行编码，这种模式通常包含在二进制表示中。

• Avro 基于模式的编码可提前指定数据结构，从而实现高效的数据序列化和反序列化。

• Avro 的二进制格式设计为自描述格式，这意味着模式信息包含在编码数据中。这种自描述性质使 Avro 能够保持不同版本数据模式之间的兼容性。

2. MessagePack:

MessagePack 是一种二进制序列化格式，直接对数据进行编码，不包括模式信息。

它使用长度可变的整数和长度可变的字符串的紧凑二进制表示法，以尽量减少空间使用。

MessagePack 不包含模式信息，因此更适用于预先知道模式并在发送方和接收方之间共享的情况。

3. BSON:

BSON 是 JSON 数据的二进制编码，包括每个值的类型信息。

BSON 的设计与 JSON 紧密相连，但它增加了二进制数据类型，如 JSON 缺乏的日期和二进制数据。
与 MessagePack 一样，BSON 不包含模式信息。

这些设计和编码上的差异导致了二进制表示法的不同：

Avro 包含模式信息并具有自描述性，这导致二进制大小稍大，但提供了模式兼容性。

MessagePack 因其可变长度编码而高度紧凑，但缺乏模式信息，因此适用于已知模式的应用场景。
BSON 与 JSON 关系密切，包含类型信息，与 MessagePack 等纯二进制格式相比，会***增加大小。

总之，这些差异源于每种格式的设计目标和功能。Avro 优先考虑模式兼容性，MessagePack 注重紧凑性，而 BSON 则在保持类似 JSON 结构的同时增加了二进制类型。格式的选择取决于您的具体使用情况和要求，如模式兼容性、数据大小和易用性。

Optimizing JSON Performance

JSON, while incredibly versatile and widely adopted in web development, is not without its speed challenges. The format’s human-readable nature can result in larger data payloads and slower processing times. So, the question arises: How can we optimize JSON to make it faster and more efficient? In this guide, we’ll explore practical strategies and optimizations that can be implemented to enhance JSON’s performance, ensuring that it remains a valuable tool in modern web development while delivering the speed and efficiency your applications demand.

Here are some practical tips for optimizing JSON performance, along with code examples and best practices:

1. Minimize Data Size:

Use Short, Descriptive keys: Choose concise but meaningful key names to reduce the size of JSON objects.

// Inefficient
{
  "customer_name_with_spaces": "John Doe"
}

// Efficient
{
  "customerName": "John Doe"
}

Abbreviate When Possible: Consider using abbreviations for keys or values when it doesn’t sacrifice clarity.

// Inefficient
{
  "transaction_type": "purchase"
}
 
// Efficient
{
  "txnType": "purchase"
}

2. Use Arrays Wisely:

Minimize Nesting: Avoid deeply nested arrays, as they can increase the complexity of parsing and traversing JSON.

// Inefficient
{
  "order": {
    "items": {
      "item1": "Product A",
      "item2": "Product B"
    }
  }
}

// Efficient
{
  "orderItems": ["Product A", "Product B"]
}

3. Optimize Number Representations:

Use Integers When Possible: If a value can be represented as an integer, use that instead of a floating-point number.

// Inefficient
{
  "quantity": 1.0
}

// Efficient
{
  "quantity": 1
}

4. Remove Redundancy:

Avoid Repetitive Data: Eliminate redundant data by referencing shared values.

// Inefficient
{
  "product1": {
    "name": "Product A",
    "price": 10
  },
  "product2": {
    "name": "Product A",
    "price": 10
  }
}

// Efficient
{
  "products": [
    {
      "name": "Product A",
      "price": 10
    },
    {
      "name": "Product B",
      "price": 15
    }
  ]
}

5. Use Compression:

• Apply Compression Algorithms: If applicable, use compression algorithms like Gzip or Brotli to reduce the size of JSON payloads during transmission.

// Node.js example using zlib for Gzip compression
const zlib = require('zlib');

const jsonData = {
  // Your JSON data here
};

zlib.gzip(JSON.stringify(jsonData), (err, compressedData) => {
  if (!err) {
    // Send compressedData over the network
  }
});

6. Employ Server-Side Caching:

Cache JSON Responses: Implement server-side caching to store and serve JSON responses efficiently, reducing the need for repeated data processing.

7. Profile and Optimize:

Profile Performance: Use profiling tools to identify bottlenecks in your JSON processing code, and then optimize those sections.

Remember that the specific optimizations you implement should align with your application’s requirements and constraints.

优化 JSON 性能

JSON 虽然用途广泛，在网络开发中被广泛采用，但在速度方面也存在挑战。这种格式的人类可读性会导致数据负载较大，处理速度较慢。因此，问题出现了： **在本指南中，我们将探讨可用于提高JSON性能的实用策略和优化方法，以确保JSON在现代网络开发中仍然是一种有价值的工具，同时提供应用程序所需的速度和效率。

以下是一些优化 JSON 性能的实用技巧以及代码示例和最佳实践：

1. 最小化数据大小：

使用简短、描述性的键： 选择简洁但有意义的键名，以减少 JSON 对象的大小。

// Inefficient
{
  "customer_name_with_spaces": "John Doe"
}

// Efficient
{
  "customerName": "John Doe"
}

尽可能缩写： 在不影响清晰度的情况下，考虑对键或值使用缩写。

// Inefficient
{
  "transaction_type": "purchase"
}
 
// Efficient
{
  "txnType": "purchase"
}

2. 明智使用数组：

尽量减少嵌套： 避免深度嵌套数组，因为它们会增加解析和遍历 JSON 的复杂性。

// Inefficient
{
  "order": {
    "items": {
      "item1": "Product A",
      "item2": "Product B"
    }
  }
}

// Efficient
{
  "orderItems": ["Product A", "Product B"]
}

3. 优化数字表示：

尽可能使用整数： 如果数值可以用整数表示，就用整数代替浮点数。

// Inefficient
{
  "quantity": 1.0
}

// Efficient
{
  "quantity": 1
}

4. 消除冗余：

避免重复数据： 通过引用共享值消除冗余数据。

// Inefficient
{
  "product1": {
    "name": "Product A",
    "price": 10
  },
  "product2": {
    "name": "Product A",
    "price": 10
  }
}

// Efficient
{
  "products": [
    {
      "name": "Product A",
      "price": 10
    },
    {
      "name": "Product B",
      "price": 15
    }
  ]
}

5. 使用压缩：

• 应用压缩算法： 如果适用，在传输过程中使用 Gzip 或 Brotli 等压缩算法来减小 JSON 有效负载的大小。

// Node.js example using zlib for Gzip compression
const zlib = require('zlib');

const jsonData = {
  // Your JSON data here
};

zlib.gzip(JSON.stringify(jsonData), (err, compressedData) => {
  if (!err) {
    // Send compressedData over the network
  }
});

6. 采用服务器端缓存：

缓存 JSON 响应：实施服务器端缓存，高效地存储和提供 JSON 响应，减少重复数据处理的需要。

7. 配置文件和优化：

剖析性能：使用剖析工具找出 JSON 处理代码中的瓶颈，然后优化这些部分。

请记住，您实施的具体优化措施应符合应用程序的要求和限制。

Real-World Optimizations: Speeding Up JSON in Practice

In this section, we dive into real-world applications and projects that encountered performance bottlenecks with JSON and successfully addressed them. We’ll explore how organizations tackled JSON’s limitations and the tangible benefits these optimizations brought to their applications. From renowned platforms like LinkedIn and Auth0 to disruptive tech giants like Uber, these examples offer valuable insights into the strategies employed to boost speed and responsiveness while still leveraging the versatility of JSON, if possible.

1. LinkedIn’s Protocol Buffers Integration:

• Challenge: LinkedIn faced challenges with JSON’s verbosity and the resulting increased network bandwidth usage, leading to higher latencies.

• Solution: They adopted Protocol Buffers, a binary serialization format, to replace JSON in microservices communication.

• Impact: This optimization reduced latency by up to 60%, improving the speed and responsiveness of LinkedIn’s services.

2. Uber’s H3 Geo-Index:

• Challenge: Uber uses JSON for various geospatial data representations, but parsing JSON for large datasets was slowing down their algorithms.

• Solution: They introduced the H3 Geo-Index, a highly efficient hexagonal grid system for geospatial data, reducing JSON parsing overhead.

• Impact: This optimization significantly accelerated geospatial operations, enhancing Uber’s ride-hailing and mapping services.

3. Slack’s Message Format Optimization:

Challenge: Slack needed to transmit and render large volumes of JSON-formatted messages in real-time chats, causing performance bottlenecks.

Solution: They optimized the JSON structure to reduce unnecessary data, including only essential information in each message.

Impact: This optimization led to faster message rendering and improved overall chat performance for Slack users.

4. Auth0’s Protocol Buffers Implementation:

• Challenge: Auth0, a popular identity and access management platform, faced performance challenges with JSON when handling authentication and authorization data.

• Solution: They adopted Protocol Buffers to replace JSON for encoding and decoding authentication-related data.

• Impact: This optimization significantly improved data serialization and deserialization speeds, resulting in faster authentication processes and enhancing the overall performance of Auth0’s services.

These real-world examples demonstrate how addressing JSON’s performance challenges with optimization strategies can have a substantial positive impact on application speed, responsiveness, and user experience. They highlight the importance of considering alternative data formats and efficient data structures to overcome JSON-related slowdowns in various scenarios.

现实世界中的优化： 在实践中加速 JSON

在本节中，我们将深入探讨现实世界中遇到 JSON 性能瓶颈并成功解决的应用和项目。我们将探讨企业如何解决 JSON 的局限性，以及这些优化为其应用程序带来的切实好处。从 LinkedIn 和 Auth0 这样的知名平台到 Uber 这样的颠覆性技术巨头，这些示例为我们提供了宝贵的见解，帮助我们了解在尽可能利用 JSON 的多功能性的同时提高速度和响应能力的策略。

1. LinkedIn 的协议缓冲区集成：

• 挑战：LinkedIn 面临着 JSON 冗余带来的挑战，以及由此导致的网络带宽使用量增加，从而导致更高的延迟。

• 解决方法：他们在微服务通信中采用了二进制序列化格式 Protocol Buffers 来取代 JSON。

• 影响：这一优化将延迟降低了 60%，提高了 LinkedIn 服务的速度和响应能力。

2. Uber 的 H3 地理指数：

• 挑战：Uber 使用 JSON 表示各种地理空间数据，但解析大型数据集的 JSON 会降低其算法的速度。

• 解决方：他们引入了 H3 Geo-Index，这是一种用于地理空间数据的高效六边形网格系统，可减少 JSON 解析开销。

• 影响：这一优化大大加快了地理空间操作，增强了 Uber 的叫车和地图服务。

3. Slack 的消息格式优化：

挑战：Slack 需要在实时聊天中传输和呈现大量 JSON 格式的消息，这导致了性能瓶颈。

解决方法：他们优化了 JSON 结构，减少了不必要的数据，只在每条信息中包含必要的信息。

影响*：这一优化提高了消息渲染速度，改善了 Slack 用户的整体聊天性能。

4. Auth0 的协议缓冲区实现：

• 挑战：Auth0 是一个流行的身份和访问管理平台，它在处理身份验证和授权数据时面临着 JSON 的性能挑战。

• 解决方法：他们采用协议缓冲区（Protocol Buffers）来取代 JSON，对身份验证相关数据进行编码和解码。

• 影响：这一优化大大提高了数据序列化和反序列化的速度，从而加快了身份验证流程，并增强了 Auth0 服务的整体性能。

这些实际案例表明，通过优化策略解决 JSON 的性能难题，可对应用程序的速度、响应速度和用户体验产生重大积极影响。它们强调了在各种应用场景中考虑使用替代数据格式和高效数据结构来克服 JSON 相关性能降低问题的重要性。

Conclusion（结论）

In the world of development, JSON stands as a versatile and indispensable tool for data interchange. Its human-readable format and cross-language compatibility have made it a cornerstone of modern applications. However, as we’ve explored in this guide, JSON’s widespread adoption doesn’t exempt it from performance challenges.

The key takeaways from our journey into optimizing JSON performance are clear:

Performance Matters: Speed and responsiveness are paramount in today’s digital landscape. Users expect applications to be lightning-fast, and even small delays can lead to dissatisfaction and lost opportunities.

Size Matters: The size of data payloads can directly impact network bandwidth usage and response times. Reducing data size is often the first step towards optimizing JSON performance.

Alternative Formats: Explore alternative data serialization formats like Protocol Buffers, MessagePack, BSON, or Avro when efficiency and speed are critical.

Real-World Examples: Learn from real-world examples where organizations successfully addressed JSON slowdowns. These cases demonstrate that optimization efforts can lead to substantial improvements in application performance.

As you continue to build and enhance your web applications, remember to consider the performance implications of JSON. Carefully design your data structures, choose meaningful key names, and explore alternative serialization formats when necessary. By doing so, you can ensure that your applications not only meet but exceed user expectations in terms of speed and efficiency.

In the ever-evolving landscape of web development, optimizing JSON performance is a valuable skill that can set your projects apart and ensure that your applications thrive in the era of instant digital experiences.

在开发领域，JSON 是数据交换不可或缺的通用工具。其人类可读格式和跨语言兼容性使其成为现代应用程序的基石。然而，正如我们在本指南中所探讨的，JSON 的广泛应用并不能使其免于性能挑战。

我们在优化 JSON 性能的过程中获得的主要启示是显而易见的：

性能至关重要： 在当今的数字环境中，速度和响应速度至关重要。用户希望应用程序快如闪电，即使是微小的延迟也会导致不满和机会的丧失。

大小至关重要： 数据有效载荷的大小会直接影响网络带宽的使用和响应时间。减少数据大小往往是优化 JSON 性能的第一步。

替代格式： 当效率和速度至关重要时，探索其他数据序列化格式，如协议缓冲区、MessagePack、BSON 或 Avro。

真实案例： 从企业成功解决 JSON 速度变慢问题的实际案例中学习。这些案例表明，优化工作可以大幅提高应用程序的性能。

在继续构建和增强网络应用程序时，请记住要考虑 JSON 对性能的影响。仔细设计数据结构，选择有意义的键名，并在必要时探索其他序列化格式。这样，您就能确保您的应用程序在速度和效率方面不仅能满足用户的期望，而且还能超越用户的期望。

在不断变化的网络开发环境中，优化 JSON 性能是一项宝贵的技能，它能让您的项目与众不同，并确保您的应用程序在即时数字体验时代茁壮成长。

Further Reading & References

进一步阅读和参考文献

Here are some additional resources for readers who want to delve deeper into the topic of optimizing JSON performance:

如果读者想更深入地了解优化 JSON 性能的主题，这里有一些额外的资源：

Revolutionizing Scalability: How Microservices and gRPC Are Changing the Game

GitHub：vaishnav-mk/protobuf-example

YT视频：https://youtu.be/MuCK81q1edU

1、Beating JSON performance with Protobuf (auth0.com)

2、LinkedIn Integrates Protocol Buffers With Rest.li for Improved Microservices
Performance | LinkedIn Engineering

3、H3: Uber’s Hexagonal Hierarchical Spatial Index | Uber Blog

4、Protocol Buffers Documentation (protobuf.dev)

5、MessagePack: It’s like JSON. but fast and small. (msgpack.org)

6、BSON (Binary JSON) Serialization (bsonspec.org)

7、Apache Avro

8、Is JSON Blazingly Fast Or? — YouTube

9、Use Binary Encoding Instead of JSON | by Shilpi Gupta | Better Programming

10、google/brotli: Brotli compression format (github.com)

11、The gzip home page

These resources offer in-depth insights into various aspects of optimizing JSON performance, including real-world case studies and alternative data serialization formats that can enhance the speed and efficiency of your applications.

这些资源深入剖析了优化 JSON 性能的各个方面，包括实际案例研究和可提高应用程序速度和效率的替代数据序列化格式。

【参考文献】

文章：[JSON is incredibly slow: Here’s What’s Faster!]（https://medium.com/data-science-community-srm/json-is-incredibly-slow-heres-what-s-faster-ca35d5aaf9e8）

作者：Vaishnav Manoj

日期：2023.09.28

上述译文仅供参考，具体内容请查看上面链接，解释权归原作者所有。

⚠️：文章翻译上如有语法不准确或者内容纰漏，欢迎各位评论区指正。

【关于TalkX】

TalkX是一款基于GPT实现的IDE智能开发插件，专注于编程领域，是开发者在日常编码中提高编码效率及质量的辅助工具，TalkX常用的功能包括但不限于：解释代码、中英翻译、性能检查、安全检查、样式检查、优化并改进、提高可读性、清理代码、生成测试用例等。

TalkX建立了全球加速网络，不需要考虑网络环境，响应速度快，界面效果和交互体验更流畅。并为用户提供了OpenAI的密钥，不需要ApiKey，不需要自备账号，不需要魔法。

TalkX产品支持：JetBrains (包括 IntelliJ IDEA、PyCharm、WebStorm、Android Studio)、HBuilder、VS Code、Goland.