This guide walks you through setting up a Python environment, installing required libraries, writing a FilmSky class with request handling, parsing HTML using regular expressions, and saving movie titles and download links, providing a practical example of web crawling for movie sites.
This article explains regular expressions, covering their definition, basic matching, metacharacters, character sets, quantifiers, grouping, alternation, escaping, anchors, zero‑width assertions, flags, and greedy versus lazy matching, with clear examples and online practice links.
This article explains how Python's re module works, covering raw string literals, the differences between match, search, and findall methods, how to retrieve match positions, and how to use numbered and named groups for extracting sub‑patterns from text.
This article demonstrates how to apply Groovy regular expressions within JMeter to extract fields from API responses, showing step‑by‑step configuration of a thread group, JSR223 post‑processor script, and variable handling for performance testing.
This article explains how regular expressions can be applied in Java and Groovy to extract information from JSON and HTML responses during web crawling, provides a reusable Java Regex utility class, demonstrates Groovy-specific regex operators, and shows sample code and console output.
This article demonstrates how to use Python's requests and regular‑expression libraries to crawl Taobao product listings, extract product titles and prices, handle pagination, and store the results, providing complete sample code for each step.
This article introduces the fundamentals of regular expressions, explains their components, syntax rules such as quantifiers and anchors, and provides a collection of frequently used regex patterns for tasks like email validation, ID numbers, dates, IP addresses, and URLs.
This article introduces Python's re module, explaining regular expression fundamentals, key functions such as match, search, compile, sub, findall, finditer, and split, detailing their syntax, parameters, flags, and providing numerous code examples to illustrate pattern matching, searching, replacing, and splitting strings.
This article provides a clear, step‑by‑step tutorial on regular expressions—covering fundamental metacharacters, quantifiers, grouping, alternation, character classes, assertions, capturing, back‑references, greedy vs. lazy matching, and includes runnable code snippets in Java and JavaScript for common validation tasks.
An unexpected CPU spike in a Java service was traced to a complex URL‑validation regex whose NFA backtracking caused catastrophic performance, and the article explains the regex engine’s behavior, identifies the problematic pattern, and shows how to refactor the expression to eliminate excessive backtracking.
This article provides a comprehensive guide to awk, covering its origins, syntax, options, keywords, operators, built‑in variables, regular‑expression meta‑characters, functions, control flow, system interaction, and practical examples that help readers efficiently process and analyze text data on the command line.
This comprehensive guide walks you through Python web crawling fundamentals, covering request handling, URL encoding, regular expressions, the requests library, XPath parsing, and lxml, complete with code snippets and practical examples to help you build effective scrapers.
This article walks you through four hands‑on Python projects—instant tagging, PDF drawing, XML‑driven website generation, and a Usenet news aggregator—explaining the underlying modules, key code structures, and how to extend each example for deeper learning.
This guide walks you through the fundamentals of building a web crawler in Python, covering how to fetch pages with the Requests library, extract data using regular expressions and XPath, and provides practical code examples for each step.
This comprehensive Linux tutorial explains why grep is indispensable, demonstrates basic and advanced string searches, multiple patterns, regex usage, recursive scans, whitespace handling, differences among grep variants, find vs grep, compressed‑file searches, IP and email extraction, case handling, exclusions, replacements, line numbers, context lines and result sorting.
A Java service suffered near‑100% CPU usage because a URL‑validation regular expression caused catastrophic backtracking, and the article explains the NFA engine behavior, identifies the regex flaws, and shows how to rewrite the pattern with possessive quantifiers to dramatically improve performance.
This guide explains how to use the Linux rename command for batch renaming files, covering basic syntax, Perl‑style regular expressions, preview options like -v and -n, case conversion, and common pitfalls, enabling efficient and safe mass file renaming.
The article presents a Java/Groovy script that crawls a website offering curated e‑books, extracts book details such as title, author, and download links using HTTP requests and regular expressions, and then inserts the collected information into a MySQL database.
This article demonstrates a Java‑based web crawler written in Groovy that uses regular‑expression parsing to retrieve paginated company data from a government portal, constructs SQL insert statements, and stores the results in MySQL, with full source code and structural screenshots.
This article explains how to update and use a Java HttpClient‑based spider that removes duplicate links, handles legacy page formats, extracts movie metadata and download URLs (magnet, ed2k, Baidu Pan), and stores the results in a MySQL database, with complete source code examples.
This article presents a Java HttpClient-based web crawler that extracts Chinese characters and their pinyin using regular expressions, stores the data in a MySQL database, and provides complete source code along with execution results and screenshots.
The article walks through a Java solution for extracting multilingual data from an HTML table using regular expressions, handling spacing and encoding issues, splitting fields, and constructing INSERT statements to populate a country_code database table.
This article introduces the popular learn‑regex GitHub project—a 24 000‑star, Chinese‑localized tutorial that covers regex fundamentals, meta‑characters, and provides online practice via regex101.com, helping programmers quickly master regular expressions across languages.
This article explains how to replace the nth occurrence of a substring in MySQL, comparing a custom stored function, an export‑sed‑import workflow, and the built‑in REGEXP_REPLACE and REGEXP_INSTR functions introduced in MySQL 8.0, with examples for both ASCII and multibyte strings.
This article provides a comprehensive guide to regular expressions, covering basic concepts, character classes, quantifiers, special symbols, greedy vs. lazy matching, backreferences, lookahead/lookbehind assertions, and practical tips for writing robust patterns in programming.
This article provides a thorough, step‑by‑step tutorial on the Linux stream editor sed, covering its basic workflow, essential options like -e, -f and -n, a full list of editing commands, text substitution techniques, line addressing, deletion, insertion, modification, transliteration, and file I/O operations, all illustrated with concrete command‑line examples.
This article introduces regular expressions in Python, explains common regex symbols, and demonstrates how to use the re module's findall, sub, and split functions for string querying, replacement, and splitting, complemented by practical code examples and detailed explanations.
This guide explains how to use the Linux grep command for powerful text searching, covering common options, file content searches, recursive scans, exclusion patterns, case‑insensitive matching, context lines, rule‑file searches, and regular‑expression techniques with practical examples.
This article provides a comprehensive collection of regular expression patterns for validating various numeric formats, character sets, and special input requirements such as email addresses, URLs, phone numbers, IDs, passwords, dates, and IP addresses, with clear examples for each case.
This article compares the speed and features of various command‑line search utilities—including grep, The Platinum Searcher, ucg, ack, sift, The Silver Searcher, git‑grep and ripgrep—provides benchmark tables for directory and file searches, and outlines ripgrep's capabilities and editor integrations.
This article describes how the author built a Python web crawler to automatically generate numeric URLs, fetch TV drama pages from the 天天美剧 site, extract ed2k download links using regular expressions, and save them into organized text files, streamlining the download process with Thunder.
This guide walks through selecting Scrapy over Requests + BeautifulSoup, explains web page types, outlines crawler use‑cases, details regular‑expression syntax and non‑greedy matching, demonstrates practical regex patterns with images, compares depth‑first and breadth‑first crawling, and covers URL deduplication and string‑encoding pitfalls in Python.
This article explains the four new ES2018 regular‑expression features—lookbehind assertions, named capturing groups, the dotAll (s) flag, and Unicode property classes—showing how they work, when to use them, and providing clear JavaScript code examples.
This article provides a comprehensive guide to Python’s re module, covering regex definitions, common methods, special character sets, pattern‑matching functions, match object attributes, and practical code examples for tasks such as validating phone numbers, IP addresses, and HTML snippets.
This tutorial walks you through building and testing regular expressions for common patterns such as floating‑point numbers, optional fractions, exponents, phone numbers, email addresses, and simple HTML tags, explaining each step and showing practical examples.
This article compiles a comprehensive set of regular expressions for validating numeric values, character strings, and various special formats such as emails, URLs, phone numbers, and monetary amounts, providing developers with ready‑to‑use patterns to streamline data validation tasks.
This comprehensive guide explains how Awk, the versatile Unix text‑processing tool, differs from sed and grep, showcases its programming features, command‑line syntax, record and field handling, built‑in variables, functions, and provides numerous practical examples to help readers start scripting with Awk effectively.
This article provides a comprehensive guide to Python regular expressions, covering regex syntax, character classes, quantifiers, groups, assertions, conditional matches, flags, the re module’s core functions, match object methods, and practical examples for effective pattern matching.
This article provides a concise tutorial on Python regular expression special characters, explaining the meaning and usage of symbols such as \d, \w, ^, $, *, +, ?, {n}, {n,}, {n,m}, |, [], and others, accompanied by illustrative examples and images.
This article walks through building and refining a Python regular expression that reliably matches a wide range of Chinese date formats—including year‑month‑day, year/month/day, and year‑month—explaining each component, testing against sample strings, and presenting the final pattern that captures all cases.
This article explains Python's regular expression special characters—such as \d, +, ?, {n}, and []—detailing their meanings, greedy vs. non‑greedy behavior, and how to use quantifiers and character classes effectively, complemented by illustrative examples and images.
This tutorial walks through building and refining a Python regular expression that reliably matches a wide range of Chinese date formats—such as "2018年6月7日", "2018/6/7", "2018-06-07" and "2018-06"—by explaining each component, testing against sample strings, and presenting the final concise pattern.
This article explains the meanings and differences of Python regex tokens \w and \W, demonstrates how they match various characters through step‑by‑step examples, and shows why \w fails with symbols like hyphens while \W succeeds, helping readers master practical regex usage.
This tutorial explains the special regex token [\u4E00-\u9FA5] for matching Chinese characters in Python, demonstrates single and multiple character matches, shows how non‑Chinese characters and spaces affect results, and provides practical examples such as matching university names.
This article provides a concise tutorial on Python regular expression special characters, detailing the meaning and usage of symbols such as \d, ?, +, {n}, |, and others, illustrated with examples and images, helping readers quickly grasp how to match digits, whitespace, word characters, and more in pattern matching.
This article revisits Python’s re module, covering functions like re.search, re.match, and re.sub, explaining common regex symbols, quantifiers, character classes, grouping, and findall usage, with clear examples and illustrations to help beginners master regular expression patterns.
This article explains how to use the special regex character [\u4E00-\u9FA5] to match Chinese characters in Python, covering single and multiple character matching, handling spaces and non‑Chinese symbols, and practical examples such as extracting university names.
This article explains the meanings of Python regex tokens \w and \W, compares them with the dot operator, and demonstrates their behavior through eight step-by-step examples with visual code screenshots to help readers master pattern matching.
This tutorial explains how the special regex characters "s" and "S" work in Python, showing how "s" matches whitespace, "S" matches any non‑whitespace, and how to use quantifiers like "+" to handle multiple characters, with clear step‑by‑step examples and screenshots.
This article explains how to prevent isolated empty seats when users select cinema seats by modeling seat layouts, defining forbidden patterns, converting them into regular expressions, and implementing concise JavaScript validation code that reduces complex nested if‑statements to a few clear lines.
This article explains Python regular expression special characters such as $ and ?, demonstrates greedy and non‑greedy matching with step‑by‑step examples and screenshots, and shows how to extract substrings correctly using appropriate patterns, helping readers master precise string extraction for web crawling.
This article explains how Python’s regex quantifiers '+' and '*' differ, demonstrating with step‑by‑step examples how '+' requires at least one occurrence of the preceding character, while '*' allows zero or more, and shows the resulting matches through clear screenshots.
This article explains how Python’s regular expression quantifier “{}” works, detailing its three forms—{n}, {n,}, and {n,m}—and demonstrates each with clear examples and visual illustrations to help readers master precise pattern matching.
This article explains why regular expressions are essential for Python web crawling, introduces the special characters ^, ., and *, and demonstrates their use with clear code examples and output screenshots, helping readers quickly grasp regex fundamentals for extracting patterns from HTML content.
This guide explains Linux regular expressions, distinguishes shell and regex meta‑characters, shows how to enable colored grep output, creates a sample text file, and provides dozens of concrete grep/egrep commands with explanations and results for common pattern‑matching tasks.
This article explains the difference between the regex quantifiers "+" and "*" in Python, showing how each affects pattern matching through step‑by‑step examples and visual results.
This tutorial introduces regular expressions across programming languages, covering fundamental metacharacters, quantifiers, grouping, alternation, character classes, assertions, capturing, backreferences, greedy vs. lazy matching, and provides practical Java code examples for common validation tasks.
This tutorial explains Python regular expression special characters like $ and ?, demonstrates greedy versus non‑greedy matching with practical examples, and shows how to capture substrings correctly for web‑crawling tasks.
This tutorial explains how to use Python's urllib module to fetch a Baidu Tieba page, apply regular expressions to extract image URLs, and then download and rename those images to your local directory.
This tutorial walks through using Python and browser developer tools to locate the NetEase Cloud Music comment API, extract encrypted request parameters, retrieve hot comments in JSON, and parse the Hot Songs chart to collect each song's name and ID with regular expressions.
This article explains Django's URLconf system, covering regex pattern matching, simple and named group configurations, default view parameters, URL aliases, reverse URL lookup in templates and Python code, and how to include app-specific URL modules for scalable routing.
The article examines a Java URL‑validation regex that caused near‑100% CPU usage, explains how Java's NFA engine and backtracking lead to catastrophic performance, and shows how to rewrite the pattern with possessive quantifiers and proper character classes to eliminate the issue.
This article analyzes why a seemingly simple Java regular expression for URL validation caused near‑100% CPU usage, explains NFA backtracking, demonstrates the problem with concrete examples, and provides practical fixes and tools to avoid catastrophic regex performance pitfalls.
During a production incident a Java service’s URL‑validation regex caused near‑100 % CPU due to catastrophic backtracking from a greedy domain pattern, which was fixed by adding missing characters to the final class and converting the domain part to a possessive or atomic quantifier, preventing exponential matching.
This step‑by‑step tutorial shows Python beginners how to create a simple web scraper that downloads, parses, and stores the Maoyan movie TOP 100 list using requests, regular expressions, and multiprocessing for fast data collection.
This guide walks you through installing grep, then demonstrates twelve practical techniques—from locating installed packages and filtering configuration files to counting matches, recursive searches, and using extended regular expressions—empowering you to efficiently search and process text on any Linux system.
This guide walks you through twelve essential grep use‑cases on Linux, from installing the tool and listing packages to filtering files, displaying line numbers, counting matches, recursive searches, exact‑word matches, and working with compressed or regex‑based searches, all illustrated with clear command examples.
This article examines the performance problems of a custom microservice gateway—including high CPU usage and frequent Full GCs—detailing root‑cause analysis, trie‑based URL routing, regex optimization, and further architectural improvements to enhance scalability and reliability.
This article explains why validating IP addresses is essential in shell scripting, then presents two Bash methods—using awk/grep and regular‑expression matching—followed by a looped version that repeatedly prompts for input until a correct IP is entered, complete with example commands.
This tutorial shows how to build a keyword‑driven web crawler for JD.com using Python's urllib for URL encoding and opening, combined with powerful regular expressions to accurately extract product information such as dog food listings, and explains how to extend the scraper for multi‑page data collection.
This article presents a concise collection of twelve fundamental Python techniques—including regex substitution, directory walking, list sorting and deduplication, dictionary sorting, conversions between dict/list/string, time manipulation, getopt argument parsing, formatted printing, numeral base conversion, executing system commands, handling Ctrl+C/Ctrl+D signals, and file reading/writing—each illustrated with ready‑to‑run code snippets.
This guide demonstrates how to combine Python's regex, BeautifulSoup, and Selenium (including Chrome and headless PhantomJS) for powerful web scraping, covering tag matching, handling Ajax, iFrames, cookie management, and practical code examples for extracting and interacting with dynamic web content.
This article explores the stability, design quirks, and advanced features of Python’s re library—including iterative matching, the undocumented scanner, and strategies for negative matching—showcasing why it remains a cornerstone of the language despite its age.
This tutorial walks through using Python's urllib and regular expressions to crawl a Baidu Tieba page, extract all .jpg image URLs, and download each image locally with a sequential naming scheme.
This tutorial explains how to collect the names and trading information of every stock listed on the Shanghai and Shenzhen exchanges using Python 3.5, requests, BeautifulSoup and regular expressions, then store the results in a file through a clear three‑step process of fetching the stock list, retrieving each stock's page, parsing the HTML and writing the data.
This guide explains Python regular expression fundamentals, covering character classes, quantifiers, groups, assertions, conditional matches, regex flags, and the essential methods of the re module, providing clear examples and practical tips for effective pattern matching and text manipulation.
This tutorial walks through building a Python web scraper that automatically downloads images from Baidu by analyzing requirements, inspecting page source, crafting regex patterns, and implementing the crawler with requests, offering step‑by‑step guidance, code snippets, and troubleshooting tips.
This guide introduces Python’s re module, explaining key functions like search, match, and sub, common regex symbols, quantifiers, character classes, grouping, and how to extract data using findall and groups, all illustrated with clear examples and diagrams.
This article reveals a collection of unconventional JavaScript techniques—including regex replacement, Unicode escapes, eval tricks, unusual operator combinations, custom getters/setters, and URL‑encoded payloads—that can evade common XSS filters and strengthen your understanding of web security.
A detailed exploration of how a complex regular expression used for shop‑name validation caused CPU spikes due to catastrophic backtracking, explaining DFA vs NFA engines, greedy, lazy and possessive quantifiers, and offering practical tips to write performant regexes.
This guide explains Linux regular expression fundamentals, distinguishes shell and regex metacharacters, shows how to enable colored grep output, and provides step‑by‑step practical examples with visual illustrations for common pattern‑matching tasks.
This article walks through solving a massive log‑keyword counting task—600,000 short messages and 50,000 keywords—by evolving from a simple grep‑based approach to regex optimizations, word‑splitting, a trie data structure, and finally a multi‑process Redis queue, achieving a performance boost from hours to under ten minutes.
This article explains how to construct regular expressions that balance matching expected strings, avoiding false matches, maintaining readability, and achieving performance, while covering when to use regex, practical JavaScript examples, accuracy techniques for phone numbers and floats, and key optimization strategies.
This article explains how to dissect JavaScript regular expressions into their structural components, covering operators, precedence, common pitfalls, and practical examples such as ID card and IPv4 validation, enabling readers to read and write regexes more reliably.
This guide explains what regex positions are, how the six ES5 anchor characters and look‑ahead/look‑behind assertions match them, and provides real‑world JavaScript examples such as inserting delimiters, formatting numbers, and building complex password‑validation patterns.
This cheat sheet compiles twenty practical regular‑expression patterns—including date, password, email, ID, IP, URL, and HTML validation examples—along with JavaScript snippets, giving developers a quick reference to boost input‑checking efficiency across front‑end and back‑end projects.
This article explains the fundamentals of the sed stream editor, covering its execution model, common parameters and actions, addressing methods, pattern and hold spaces, label usage, and provides multiple practical examples illustrating typical command patterns and advanced techniques.
This article explains the two main aspects of using regular expressions in JavaScript—string methods such as search, replace, match, and split, and the RegExp object with its properties, constructor, and methods like exec, test, and compile, including practical tips and common pitfalls.
Learn to use Python's urllib and regular expressions to fetch Baidu Tieba web pages, extract image URLs, and download the images to your local machine, with step-by-step code examples and explanations for beginners tackling web scraping challenges.
This article introduces awk as a versatile text‑processing language, explains its origins and variants, details command‑line syntax and three invocation methods, and walks through practical examples—from extracting fields in system files to using built‑in variables, conditionals, loops, arrays, and formatted output with print and printf.
This article explains how Python’s re module implements regular expressions—a powerful, language‑agnostic tool for pattern matching, validation, searching, and text manipulation—covering compilation, core functions, metacharacters, grouping, and practical usage examples.
The article recounts a real‑world Oracle SQL case where a REGEXP_SUBSTR‑based IN subquery caused the optimizer to abandon an index range scan, explores why predicate pushdown fails with CONNECT BY recursion, documents attempted hints, rewrites, and the ultimate lessons for SQL performance tuning.
This article walks through practical regular‑expression exercises, explains each solution with clear JavaScript examples, and then expands to real‑world patterns for matching dollar amounts, 24‑hour times, IP addresses, quoted strings, and HTML tags, offering tips for building robust regexes.
This guide explains grep's core concepts, syntax, and options, covering basic and extended regular expressions, character classes, quantifiers, anchors, grouping, and backreferences to help you efficiently filter and search text on the command line.
The article highlights four dangerous regular expression patterns that can cause severe performance degradation in Node.js, turning millisecond operations into minutes, potentially leading to timeouts, event‑loop blocking, and broader security risks, and points to additional encoding and cookie safety recommendations.
This guide explains how to use the awk command together with regular expressions to filter and manipulate text in Unix/Linux, covering basic syntax, meta‑characters, pattern matching, character classes, anchors, escaping, and practical examples for common filtering tasks.
This article explains regular expression delimiters, common metacharacters, quantifiers, anchors, character classes, logical operators, negation, and escaping, providing clear examples of each pattern and how they match specific strings in target text.
This article explains why regular expressions are essential, introduces JavaScript regex syntax and creation methods, compares ES3 and ES5 behaviors, details literals, character classes, quantifiers, anchors, modifiers, and demonstrates practical patterns for URLs, HTML tags, and quoted strings.
This article walks through using PHP's cURL extension to crawl tens of thousands of Zhihu user profiles, parse the HTML with regular expressions, store the extracted data efficiently, and present the results with responsive charts and dashboards.
This guide explains how to use the GNU grep tool on Linux and Unix to perform powerful text searches with basic and extended regular expressions, covering pattern matching, character classes, wildcards, logical operators, quantifiers, output formatting, and differences between grep and egrep.
