This article walks through a Python fan's question about storing JSON from web pages during crawling, presents four step‑by‑step code solutions—including regex, BeautifulSoup, and json.loads—and offers practical tips for clean extraction and reliable scraping.
This article explains how to use pandas' json_normalize function to transform different JSON formats—including simple objects, nested objects, lists, and deeply nested structures—into DataFrames, covering parameters such as record_path, meta, max_level, sep, errors, and prefix handling, with practical code examples.
This article describes how a Python‑based diff utility was created to compare old and new API responses during a promotion change‑record migration, detailing its implementation, handling of JSON structures, improvements over the first version, and plans for integration with an API testing platform.
This guide explains how to install jq on CentOS 8, introduces its command‑line syntax, and provides step‑by‑step examples for organizing JSON output, accessing object properties, and iterating over arrays using jq filters.
Choosing the correct boolean property name in JavaBeans—using `success` rather than `isSuccess`—ensures consistent getter/setter generation and avoids mismatched JSON serialization across frameworks like fastjson, Gson, and Jackson, preventing subtle bugs in production environments.
cURL author Daniel Stenberg announced plans to add native JSON handling, explaining its importance for REST APIs, the common pain points developers face, and introducing two new command‑line options that simplify sending JSON payloads and headers.
cURL’s creator Daniel Stenberg plans to add native JSON handling with new command‑line options that streamline sending JSON payloads and headers, addressing common REST API usage, user convenience, and shell quoting challenges.
This article explains the conceptual and practical differences between JavaScript's null and undefined values, covering their definitions, type checking methods, comparison behavior, arithmetic conversion, JSON serialization, and best practices for usage.
This article introduces the open‑source low‑code front‑end framework Amis, explains its JSON‑based page generation, highlights its low entry barrier, rich built‑in components, flexibility, and real‑world usage, and provides practical code examples to help developers get started quickly.
When running Sentry Relay in static or proxy mode, you configure project settings on the filesystem under the .relay/projects directory, defining required fields such as slug, publicKeys, and allowedDomains, with JSON examples and detailed explanations of each option.
This article explains the MySQL JSON data type, demonstrates how to store structured and semi‑structured data with JSON objects and arrays, shows practical table designs for user login and profiling, and details virtual columns, function indexes, and multi‑valued indexes for fast querying.
This article examines workload analysis and query performance differences between PostgreSQL and MySQL, focusing on JSON handling, indexing strategies, concurrency control, benchmark results, and replication features, while offering configuration tips to improve each database’s speed and efficiency.
This guide explains how to install the DTLE RPM, prepare MySQL source and target instances, create job JSON files to rename databases or tables during transfer, submit jobs via Nomad, verify synchronization, and clean up jobs, providing a complete end‑to‑end data migration workflow.
Learn three JavaScript approaches—using map with join, map with manual concatenation, and reduce—to extract a specified property from each object in a JSON array and combine the values into a comma-separated string, with full code examples.
This article demonstrates how APIJSON enables developers to implement full CRUD, query, and aggregation operations with just a few lines of code, reducing boilerplate, handling permissions, and supporting complex relational queries through a unified JSON request format.
This tutorial explains how Java developers can use Jackson Mixins to add custom JSON serialization and deserialization behavior to classes that lack default constructors or getters, without modifying the original classes, and shows how to register Mixins via ObjectMapper or custom modules.
This article introduces MySQL 8.0's enhanced JSON capabilities, covering storage constraints, utility functions, path expressions, in‑place updates, indexing, merging, extraction operators, and the JSON_TABLE function, with clear code examples for each feature.
When integrating a third‑party API, building deeply nested JSON structures can become cumbersome, but using Java's double‑brace initialization for maps and JSONObjects dramatically reduces boilerplate code while keeping the payload readable and maintainable.
This article introduces SPL, an open‑source Java‑embeddable computation library that outperforms traditional embedded databases and DataFrame tools by handling both tabular and nested JSON data, supporting JDBC, SQL‑like queries, multi‑source integration, and persistent .btx files with concise code examples.
This tutorial demonstrates how to read, write, and convert CSV, JSON, and XML data using Python's built‑in modules and popular libraries such as pandas and dicttoxml, providing clear code examples for each format and showing how to interconvert them efficiently.
This article provides two Python scripts that transform raw interface‑copied data and URL query strings into properly formatted JSON, including dependency details, sample input, conversion code, and resulting output, offering a straightforward solution for developers handling unquoted JSON-like text.
This article shows how to streamline Java backend unit tests by loading JSON fixtures, deserializing them into objects, and re‑serializing results for concise assertions, while providing naming conventions, Maven setup, FastJSON tricks, and advanced Mockito techniques to replace verbose manual object construction.
This article walks through the design and implementation of a lightweight JSON parser in Java, covering the underlying lexical and syntax analysis, token definitions, core parsing algorithms, testing strategies, and a brief demonstration of JSON beautification, providing developers with a clear understanding of JSON processing fundamentals.
This article explains why traditional SpringBoot CRUD endpoints require dozens of lines of code and how APIJSON lets you perform all create, read, update, delete, and statistical operations on any table with only a few lines of configuration and a single generic interface.
This tutorial walks through using Fastjson to create, add, delete, retrieve, and manipulate JSON objects in Java, highlighting common pitfalls and showcasing advanced methods such as compute, computeIfAbsent, and custom iteration techniques.
This article explains how leveraging JSON serialization can dramatically simplify and accelerate Java unit test development by reducing boilerplate code for data mocking and verification, offering practical examples, naming conventions, resource organization, and integration tips for backend projects.
This article introduces MySQL 8.0’s enhanced JSON capabilities, covering data types, storage limits, indexing, core functions like JSON_SET, JSON_EXTRACT, path expressions, merging, and the JSON_TABLE feature, while providing practical code examples for developers.
The article compares Go's built‑in encoding/json with third‑party libraries jsoniter, easyjson, jsonparser, and the author's jsonvalue, outlining each one's features, performance benchmarks, and ideal use cases—standard library for simplicity, easyjson for maximum speed with code generation, jsonparser or jsoniter for selective extraction, and jsonvalue for flexible, case‑insensitive handling.
This guide walks Java developers through installing Groovy, using its .groovy files, manipulating lists, maps, conditionals, loops, and leveraging built‑in JsonBuilder and HTTPBuilder for JSON handling and HTTP requests, all with clear code examples.
This article introduces MySQL 8.0's enhanced JSON capabilities, covering key constraints, storage functions, GeoJSON support, indexing, in‑place updates, essential JSON utilities, path expressions, extraction, modification techniques, and the powerful JSON_TABLE feature with clear code examples.
This tutorial demonstrates how to use Go's standard and third‑party libraries to parse and generate YAML, JSON, and XML files, covering data structures, unmarshalling, marshalling, handling maps, and producing readable output with code examples.
This guide demonstrates how to transform a JSON array into a CSV file with pandas, then sort the resulting CSV by specific columns using two different Python approaches, providing complete code snippets and explanations for each step.
This article summarizes the most useful MySQL 8.0 JSON features—including storage limits, indexing, in‑place updates, path expressions, merging, and table functions—providing clear code examples and guidance for developers who need to work with JSON data in MySQL.
This article explains the purpose of configuration files, compares common formats such as INI, JSON, TOML, and YAML, and demonstrates how to read each of them in Python using built‑in libraries or third‑party packages while highlighting their advantages and pitfalls.
This guide explains how Spring MVC can automatically negotiate response formats using the Accept header, allowing a single endpoint to return either JSON or XML based on a query parameter or MIME type, without duplicating code or routes.
This article shares practical experiences and lessons learned while integrating with Jira's REST API, covering the absence of Chinese documentation, handling of HTTP status codes, inconsistent and overly nested JSON responses, demo errors, mixed language fields, and the differences between POST and PUT methods.
This article compares Python's built‑in json module with faster alternatives like ujson, rapidjson, and the Rust‑based orjson, showing benchmark results, installation steps, code examples, and a known ujson indentation bug to help developers choose the most efficient JSON library.
This tutorial demonstrates how to capture network packets from the Super Schedule Android app, perform a login request with required headers, and repeatedly fetch and parse topic data using Python urllib2 and JSON handling, enabling infinite scrolling of user‑generated topics.
This article presents a collection of practical Python techniques, including variable swapping without a temporary variable, using dictionary and set comprehensions, leveraging the Counter class for counting, pretty‑printing JSON, solving FizzBuzz concisely, inline conditional expressions, list slicing, dictionary get method, and generating combinations with itertools.
This article explains how to modify JMeter's source code so that the JDBC Request sampler returns results in a clean JSON format, covering environment setup, code changes, building the custom JAR, integration, and the resulting improvements in readability and automation.
This article demonstrates how to call third‑party APIs in Java projects by importing the HttpClientUtil utility, performing GET and POST requests (with and without parameters), handling JSON responses with a custom JsonUtils class, and includes complete code examples for each step.
The article investigates why Python's built‑in json.dumps can be slow on large data structures, compares the performance of ujson, python‑rapidjson, simplejson, and the Rust‑based orjson, provides benchmark code, installation commands, and discusses a bug in ujson's indent handling.
This article explains a systematic process for evaluating and selecting the most suitable high‑performance JSON library for Python, covering the need assessment, benchmark definition, filtering by additional requirements, and detailed benchmark results that highlight orjson as the fastest option for small‑message encoding while discussing trade‑offs such as safety, customizability, and ecosystem support.
The Dolphin system for JD International channel introduces a fully configurable, drag‑and‑drop custom layout architecture that separates layout and content data, enabling business users to build personalized floor modules with minimal coding and deploy them instantly across web, mobile, and mini‑program platforms.
The article explains how Python's functools.singledispatch (PEP 443) provides a clean, extensible way to serialize arbitrary objects to JSON, avoiding custom default functions or subclassing JSONEncoder, and discusses alternatives, pitfalls, and related tools such as zope.interface and attrs.
This article explains the difference between FastJSON's getInteger and getIntValue methods, analyzes a common validation bug in a custom isRight() implementation, and provides corrected code examples and optional global switches for robust response handling in Java backend projects.
This guide explains how to use the JavaScript Fetch API to retrieve and send JSON data, covering basic GET requests, parsing responses, configuring request options, handling POST submissions with appropriate headers, and using polyfills for unsupported browsers.
This tutorial walks you through analyzing a JavaScript‑driven website, discovering the hidden API, configuring request headers with Postman, and writing a Python scraper that extracts book titles, authors, codes, and prices from epubit.com.
This article compares ClickHouse and Elasticsearch for API log storage, detailing development activity, schema handling, query performance, statistical functions, MySQL integration, new features, and practical drawbacks, while providing concrete SQL examples and migration tips.
This article presents a complete Python‑based seat reservation system that uses PySide2 to build an interactive graphical interface for selecting and booking seats, stores configuration and occupancy data in JSON files, and provides command‑line utilities for checking in, checking out, making reservations, and handling temporary leaves, illustrating both front‑end UI design and back‑end logic in a single project.
This guide walks you through analyzing Toutiao’s Ajax requests, extracting image URLs, and using Python’s requests library to download street‑photo pictures in bulk, complete with code snippets and tips for pagination and future enhancements.
Prometheus HTTP Service Discovery (HTTP SD) offers a flexible, JSON‑based approach for dynamically locating targets, contrasting with file‑based SD in event handling, update frequency, format, transport, and security, while outlining endpoint requirements, response headers, and providing concrete JSON examples for practical implementation.
This tutorial explains how to move data desensitization to the JSON serialization stage using Jackson, defines a @Sensitive annotation, custom strategies, a contextual serializer, and demonstrates the approach with a User class example that masks personal fields during serialization.
This article provides a detailed examination of the YYModel framework’s source code, explaining how it leverages Objective‑C runtime to parse JSON into model objects, covering key files, internal classes, mapping mechanisms, and the core conversion methods with illustrative code examples.
This tutorial demonstrates how to use the jq command‑line tool to extract an array of objects from a JSON file, reshape the data into a two‑column format, and output it as properly formatted CSV, including handling of quoting and raw output options.
This tutorial explains how to integrate AJAX fetch calls with Django views for both GET and POST requests, covering header configuration, CSRF handling, JSON data exchange, and the updated method for detecting AJAX requests in Django 3.1 and later.
The article compares ClickHouse, Elasticsearch, and MySQL for log storage and analysis, highlighting ClickHouse's active development, SQL support, JSON handling, performance, storage efficiency, integration options, and practical query examples to help developers decide the best backend for observability pipelines.
This article provides a thorough overview of Python file handling, covering opening and closing files, reading and writing modes, absolute and relative paths, file copying, CSV read/write, in‑memory streams with StringIO/BytesIO, sys I/O redirection, and data serialization using JSON and pickle.
This tutorial explains how to create, read, and write JSON files using Python's json module, load them into Pandas dataframes, perform data manipulation, rename columns, save to CSV, fetch JSON from URLs, and visualize the data with Seaborn, providing code examples and visual illustrations.
This tutorial walks you through Python's built‑in JSON handling, covering reading JSON files, converting between JSON strings and Python objects, using pandas for JSON parsing, and applying serialization, deserialization, and pretty‑printing techniques with complete code examples.
This tutorial explores jq's advanced capabilities, demonstrating how to combine filters with the pipe operator, use functions like keys, length, select, map, and join, and transform JSON data into new structures and formats through practical command‑line examples.
This step‑by‑step guide shows how to log into Toutiao, locate the fan list via browser dev tools, capture the AJAX request URLs, decode Unicode nicknames, paginate through all pages, and save the results as JSON using Python.
This article explains the difference between MySQL multi-value indexes and composite indexes, demonstrates how to create and query multi-value indexes using JSON columns, and shows performance benefits and practical scenarios when dealing with tables that have a large number of columns.
This guide shows how to use the jq command‑line tool to elegantly format, query, and extract data from JSON responses across Linux, Windows, and macOS, providing practical examples, syntax basics, and integration with curl for API testing.
This tutorial demonstrates how to use Python, requests, and openpyxl to analyze a job‑listing website, construct the appropriate Ajax URLs, write a scraper that parses JSON responses, and export the collected position data into an Excel workbook.
This article explains how to create a custom Spark DataSource that reads JSON data from a standard REST API, covering the design of DefaultSource, schema inference, data fetching, and integration with Spark SQL for seamless downstream processing.
This article explains how to use MySQL's EXPLAIN FORMAT=JSON to view detailed execution plan costs, illustrates table structures, walks through two query examples with cost breakdowns, and clarifies the calculation of read_cost and eval_cost for both simple and join queries.
This article provides a comprehensive guide to using Jackson with Spring Boot, covering its core modules, Maven dependencies, ObjectMapper usage, JSON tree model, custom deserializers, XML handling, configuration options, and practical code examples for serialization and deserialization.
The article examines Fastjson’s features, demonstrates basic usage, compares it with other Java JSON libraries, and explains why the author decided to abandon Fastjson due to its lower popularity, design shortcomings, numerous open issues, and a history of serious AutoType vulnerabilities.
This guide explains how to install the GsonFormat plugin in IntelliJ IDEA and use it to quickly transform JSON strings into JavaBean classes with generated getters and setters, dramatically reducing manual mapping effort and improving development efficiency.
This article chronicles the step‑by‑step evolution of Kuaishou's special‑effects authoring tool—from early QWidget layouts through QML redesign, then JSON/Lua configuration, and finally dynamic QML loading—highlighting how each stage reduced code size, improved developer efficiency, and enabled seamless hot updates without app releases.
This article explains why PHP's json_encode sometimes returns a JSON object instead of an array, demonstrates several common scenarios, and provides practical code solutions to ensure the desired array format in the resulting JSON.
This article introduces nine popular JSON tools—including online validators, formatters, comparators, CLI utilities, IDE plugins, and editors—that help developers verify, format, compare, and manipulate JSON data efficiently across various platforms.
This guide reviews fifteen essential Python packages—from data‑visualisation with Dash and image handling with Pillow to web requests, JSON parsing, and home automation—explaining their key features, typical use‑cases, and why they’re valuable tools for developers.
This guide demonstrates how to retrieve a list of WeChat public account articles by constructing the appropriate API URL, examining its query parameters, viewing the JSON response, and using a Python script to parse the data and generate a markdown file of titles and links.
This tutorial explains what an API is, shows how to install and use the Python requests library to make GET requests, interprets common HTTP status codes, and demonstrates parsing JSON data from the Open Notify ISS API using the built‑in json module.
This article explains how the KEMIS framework provides a universal, declarative JSON‑based solution for building Management Information System (MIS) pages, covering component declaration, data fetching via initApi and api, variable resolution, expression‑based attributes, and custom component registration with React examples.
This article provides PHP functions that demonstrate how to perform HTTP GET, POST, and JSON‑encoded POST requests using cURL, including error handling, timeout settings, SSL options, retry logic, and a usage example for calling an API.
This article explains how to design a non‑intrusive unified JSON response structure for Spring MVC applications, defines the standard JSON schema, provides Java enums and generic Result classes, demonstrates usage with @ResponseResultBody and @RestControllerAdvice, and shows comprehensive exception handling techniques.
This tutorial demonstrates how to use Jackson's ObjectMapper and ObjectNode to programmatically add, modify, and delete fields in JSON strings or Java objects, providing clear code examples and explaining the underlying JsonNode API for flexible JSON manipulation.
This article demonstrates how to use standard shell utilities such as grep, cut, sort, uniq, awk, and join to quickly extract insights—like top companies, common surnames, popular given names, age distribution, and hometown rankings—from a JSON dataset of Beijing points‑based residency applicants.
This guide shows how to install the "Little Emperor" VSCode extension, add a 20‑in‑1 NES game pack, configure a list.json file with ROM metadata, and launch classic games like Contra and Mario directly inside the editor, complete with usage tips and warnings.
This article explains why configuration files are essential, compares popular formats such as INI, JSON, TOML, and YAML, and provides Python code examples for reading each type while highlighting their advantages, limitations, and security considerations.
This tutorial walks you through using Python's requests, lxml, and JSON parsing to automatically crawl the King of Glory website, extract hero skin URLs, and download the images into organized folders while displaying progress in the console.
This tutorial walks you through creating a Spring Boot web project, adding the starter dependency, implementing a REST endpoint, customizing Tomcat port and context path, and configuring Jackson for JSON output such as date formatting and global ObjectMapper settings.
This article explains how MySQL 8.0’s JSON data type enables range‑based traversal of JSON arrays, demonstrates extracting array elements with path expressions, and provides stored‑procedure examples—both a traditional loop version and an optimized version using the new "$[m to n]" syntax.
This tutorial explains how Spring Boot returns JSON using the default Jackson library, compares it with Alibaba's FastJson, demonstrates handling of null values, and shows how to encapsulate responses in a unified structure with status codes and messages for backend development.
This article demonstrates how to design a non‑intrusive, unified JSON response structure for Spring Boot applications, defines a standard Result wrapper and status enum, shows static factory methods, and explains global handling via @ResponseResultBody, @RestControllerAdvice, and centralized exception processing.
This tutorial shows how to use Python's urllib and json libraries to call the Kuaidi100 API, retrieve real‑time logistics data for various Chinese courier companies, and display the tracking timeline, while explaining how to discover the correct request URL via browser dev tools.
This article introduces a self‑implemented Swagger UI built on think‑vuele, explains its architecture and dependencies, provides step‑by‑step usage instructions and Maven integration, and details performance optimizations such as API summary loading, mock data generation, and customizable request headers.
This article extends the previous JsonPath utility guide by demonstrating how to write comprehensive Groovy‑based Spock unit tests, covering Maven/Gradle setup, basic and data‑driven demos, detailed test cases for JSON path extraction, array operations, statistical functions, and a deliberately introduced bug with its console output.
This article demonstrates how to use JsonPath's built‑in functions such as $.ss.min(), $.ss.max(), $.ss.avg(), $.ss.stddev(), $.ss.length() and $.ss.sum() to compute minimum, maximum, average, standard deviation, length and sum of JSON array elements, providing Java code examples and expected console output.
This article explains how to use JsonPath in Java to filter JSON data, covering operators, functions, and practical examples such as checking values in arrays, subsets, size constraints, and empty checks, with complete code snippets for each case.
This tutorial shows how to use standard Unix shell tools such as grep, cut, sort, uniq, awk, and join to extract insights—top companies, most common surnames, popular given names, age distribution, and hometown statistics—from a JSON dataset of over 6,000 Beijing residency applicants.
This tutorial demonstrates how to use JsonPath combined with regular expressions to filter JSON arrays, perform case‑insensitive matches, and discuss the limitations of regex validation on node values, providing concrete Java code examples and console outputs.
This article explains how Laravel routes and controllers can return various HTTP responses—including plain strings, JSON arrays, custom Response objects with headers, cookies, redirects, view rendering, JSONP, and file downloads—while showing the corresponding PHP code for each technique.
This article explains why the new Java development manual forbids returning large Long values as JSON, explores the IEEE754 double‑precision limits that cause JavaScript Number precision loss, and provides practical solutions such as converting Longs to strings to avoid silent data corruption.
This article demonstrates how to integrate the JsonPath library into a Java project, explains its syntax for querying JSON structures, and provides practical code examples for extracting authors, prices, and entire nodes from a sample JSON document.
Explore essential Python tricks—from dictionary and set comprehensions to using Counter for counting, pretty‑printing JSON, and building a quick XML‑RPC file service—showcasing concise code snippets that illustrate the language’s clean syntax and powerful standard library.
This tutorial walks through building a simple Python web crawler that searches the Pansou site, handles AJAX‑loaded JSON data, extracts file links, and enables interactive downloading, illustrating core backend techniques such as HTTP GET requests, JSON parsing, and user‑driven pagination.
