This is a JavaScript port of the URL regex from http://stackoverflow.com/a/190405/384062 that includes a bug fix and some optimization. Mathias Bynens's Regenerate was used to convert unicode escapes. Bug fix: Eliminated stray | falsely allowing querystring to contain | Optimization: Merged alternated character classes in querystring and fragment identifier portions for better performance.

looks for blank keys in the query string and remove it, in order to make shorter request.

Extract resource location, name and query parameters from a URL (JavaScript version)

A solution for capture query params.

Finds the protocol, subdomain, ((domain, extension)/ipaddress), port, filepath (split in path and filename), the route and the query string.

Separates media query into rule and content

Extract resource location, name and query parameters from a URL

A simple URL regex that can handle most "properly" formed URLs, and some URIs. It features named groups to easily destruct matches. URIs can use relative paths (../ and ./) to resources. Example (JavaScript) let url = "https://username:password@example.org:8080/path/to/resource?query=term&query=terms#fragment"; let regex = /{{ URL RegEx }}/i; let { href, origin, protocol, scheme, username, password, host, hostname, port, pathname, search, hash } = regex.exec(url).groups; // href → "https://username:password@example.org:8080/path/to/resource?query=term&query=terms#fragment" // origin → "https://" // protocol → "https:" // scheme → "https" // username → "username" // password → "password" // host → "example.org:8080" // hostname → "example.org" // port → "8080" // pathname → "/path/to/resource" // search → "?query=term&query=terms" // hash → "#fragment"

Matches protocol, domain, port, path, query and anchor as named capturing groups.

A well-documented, easy to modify bulletproof regular expression that matches complete URLs or URL components. Components include: Schema scheme/protocol: use an OR statement to add FTP, etc. hostname: use OR statements to more TLDs port: matches leading zero; to disable, change the first block in the subexpression to [1-9] from [0-9] path query: to capture subcomponents of the query string, delete the target symbol in the `` subexpression fragment ☛ The name of the captured subexpression is usually case-sensitive. Substitution Complete URL ${URL}, \1, or its equivalent, can be used to backreference or substitute the complete URL. \1 $1 ${URL} $+{URL} URL Component Map ${SCHEME} → \2 ${HOSTNAME} → \3 ${PORT} → \4 ${PATH} → \5 ${QUERY} → \6 ${FRAGMENT} → \7 Plug & Play substitution/backreference alternatives \2\3\4\5\6\7 $2$3$4$5$6$7 ${2}${3}${4}${5}${6}${7} ${SCHEME}${HOSTNAME}${PORT}${PATH}${QUERY}${FRAGMENT} $+{SCHEME}$+{HOSTNAME}$+{PORT}$+{PATH}$+{QUERY}$+{FRAGMENT}

Validate an url with hostname or ip and port. Furthermore provides: the entire url the protocol the hostname/ip the port the path the querystring

Everything, including proto, user:pass, host, query params and anchors

Some times we need replace de first select in a query to another. In my case i want replace to "Select top 1". With that a can replace any select to select top 1.

Tests for valid http or https protocol URL. *2 groups- one for protocol,domain, and any subdomains; and one for path, query, params, and fragments(if any. The following WILL match: http://foo.com/blah_blah http://foo.com/blah_blah/ http://foo.com/blah_blah_(wikipedia) http://foo.com/blah_blah_(wikipedia)_(again) http://www.example.com/wpstyle/?p=364 https://www.example.com/foo/?bar=baz&inga=42&quux The following WILL NOT match: http://✪df.ws/123 http://userid:password@example.com:8080 http://userid:password@example.com:8080/ http://userid@example.com http://userid@example.com/ http://userid@example.com:8080 http://مثال.إختبار http://例子.测试 http://उदाहरण.परीक्षा http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com http://1337.net http://a.b-c.de http://223.255.255.254 The following SHOULD NOT and DO NOT match: http:// http://. http://.. http://../ http://? http://?? http://??/ http://# http://## http://##/ http://foo.bar?q=Spaces should be encoded // //a ///a /// http:///a foo.com rdar://1234 h://test http:// shouldfail.com :// should fail http://foo.bar/foo(bar)baz quux ftps://foo.bar/ http://-error-.invalid/ http://a.b--c.de/ http://-a.b.co http://a.b-.co http://0.0.0.0 http://10.1.1.0 http://10.1.1.255 http://224.1.1.1 http://1.1.1.1.1 http://123.123.123 http://3628126748 http://.www.foo.bar/ http://www.foo.bar./ http://.www.foo.bar./ http://10.1.1.1 I only needed http and https; however others could be added.

Pattern to match all the possible variables in a SPARQL query. It was built on a negation class of the following characters: white spaces, newlines, punctuation (except for ?), closing parenthesis and double quotes.

Tokenizes a search query into individual parts: Group 1: Open Param Group 2: Close Param Group 3: Keyword Group 4: Value Group 5: Quoted Value Group 6: Regex Group 7: Regex Flag/Mod

Validation pattern to validate the minimum_should_mach value in opensearch and elasticsearch queries. For more information on the minimum_should_match field have a look here for opensearch or here for elasticsearch

diversitystars.com

IsHimMarketing.com

for JS regular expression to validate any http|https|ftp|IPv4 address, supported: authority username:password (example https://username:password@example.com); port :0-65565 (example https://example.com:80); query/queries ?c=1 or ?c=1&d=x (example https://example.com/main.php?c=1&d=x); fragment #name (example https://example.com/main.php#top); WaybackMachine URLs contains *;

A complete validation for GIT branch names. Includes typical branch names such as main and develop as well as feature, release branches and more. Examples: feat/add-i18n-module release/v1.0.0 main next/staging docs/fix-typo `bugfix/182/encode-slashes-in-url-query

Support any types of URL for https and http protocol. http or https [optional] domain name [mandatory] file path [optional] query parameter [optional]

Validates protocol, sub-domain, domain, and top-level domain. No port number and query string parameters validation is made.

Get all table from sql query string | 从SQL查询语句中获取所有表名。 WelineFramework PHP8 。

Make sure http[s]:// uses two slashes, not one. IIS rewrite rules removes double slashes in the raw URL, breaking YOURLS (PHP) for example. This regexp changes all single slashes to double after a web protocol, including nested querystrings.

This pattern finds a parameter (sst) key + value in a GET request URL. When replaced with an empty string, effectively removes the parameter. Works with both full URLs and isolated query strings. Works in PCRE and PCRE2. Full use case: if (isset($_GET["sst"])) { // validate // modify active session $query = $_SERVER["REQUEST_URI"]; $pattern = "/(sst=+&)|((\?|&|^)sst=+$)/"; $uri = preg_replace($pattern, "", $query); unset($_GET["sst"]); header("location: https://example.com$uri", true, 308); }

Need to FULLY Break Out EVERY Component of a URL? Like, as in "every constituent element individually accessible in its own named capture group?" Need it to be pre-optimized and fully ECMA-compliant? Want to see exhaustive unit tests proving these claims (144 are included; all 144 execute in 6.5ms. Total.)? Then you just lucked out. What Does It Do? Fully breaks down a URL, acting the same (meaning the same capture group names apply regardless of use case; makes for MUCH easier interaction in ones code) on: Relative Paths (./, .//) Absolute Paths (/) Fully-qualified domains (https://www.domain.com/) Partially-qualified domains (https://domain.com/) Dynamically-protocol'd domains (//domain.com/) ...with each separated out into HOST, PROTOCOL, DOMAIN, and RELATIVE path prefix. BUT WAIT! THERE'S MORE! It then further proceeds to break out (also into individually-named groups, but only when present): URI Path (/some/path/to/a/file/) Full File Name, with or without Extension (filename.ext) File Name (filename) Extension (.ext) QueryString Parameters (?query=string) Anchor Tags/Routing (#SomeAnchor) Best of all, EVERY ONE of these are delivered in named capture groups (so you're looking at obj.groups.DOMAIN instead of object[3]) Examples: Fully-Qualified Domain Full Request: https://www.domain.com/some/path/to/a/file-with.ext?Plus=QueryString#AndAnchor Host: https://www.domain.com/ Protocol: https:// Domain: www.domain.com/ Path: some/path/to/a/ FullFileName: file-with.ext FileName: file-with Extension: .ext QueryString: ?Plus=QueryString Anchor: #AndAnchor Relative Path Full Request: ../../../../some/path/to/a/file-with.ext?Plus=QueryString#AndAnchor Relative: ../../../../ Path: some/path/to/a/ FullFileName: file-with.ext FileName: file-with Extension: .ext QueryString: ?Plus=QueryString Anchor: #AndAnchor

This works against a list of hyperlinks from the 'USS Marmora (1862)' article You can include File: pages by removing the File:| from the regex. I could improve how the remaining query for urls containing index.php, for now I recommend splitting in your chosen programming language. According to guidelines at https://en.wikipedia.org/wiki/Help:URL

Capture URL without Query Parameters /^(+).*/gm

Extracts parts of an URL into regex groups: ((?:(?:http|ftp|ws)s?|sftp):\/\/?)?(group 1): extracts the protocol (+\.+|localhost)(group 2): extracts the hostname (:\d+)?(group 3): extracts the port number ((?:\/\w+)\/)?(\w\-.]++)?(groups 4 & 5)*: extracts the path part (+)?(group 6): extracts the query part (#[\w-])?(group 7)*: extracts the hash part For every part of the regex listed above, you can remove the ending ? to force it (or add one to make it facultative). You can also remove the ^ at the beginning and $ at the end of the regex so it won't need to match the whole string. See on [stackoverflow.com. *Note: this regex is not 100% safe and may accept some strings which are not necessarily valid URLs but it does indeed validate some criterias. Its main goal was to extract the different parts of an URL not to validate it.*

trino kill query ID

trino kill query

SQL comments on Big Query

any given url inside a text will be recognized and split into different groups: url (full url) scheme hostname (subdomain + domain + tld) port path query (GET-parameters) while the only group required for a match is the hostname, therefore example.com would allready be a match.

Searches for the first list element in a graphql query, which allows for filtering and pagination, except for the group node

If you got a malformed URL with a query string not starting with a question mark, this Apache rule will catch it and make a redirection, replacing the first ampersand with the mandatory question mark for a query string. The negative lookahead will make sure that it don't replaces a well formed query string (if the tested text contains a question mark) RewriteRule ^(?!.\?)(.?)\&(.*)$ /$1?$2 [R=302,NC,L]

Conforms to various RFC specifications Captures key components of url: Protocol Authority Port Path Query Fragment Also because this is specifically looking for an image file, captures full file name & extension (jpeg/jpg/gif/png) Limitations to this regex: Only http or https protocols are allowed Only named hosts can be used, not IP addresses Does not support unicode Does not support escaped characters The path & filename detection is still a little "free" in standard URI style - they allow a wide range of characters

This regex can capture any column name from a select query. Be the original name, like are named on table, renamed with a reserved word AS or even without explicit AS. Go on, and test with your query ;)

Tries to find the column names from the given SQL query.

Youtube URL validator Credit to: phuc77 The captured groups are: protocol subdomain domain path video code query string Works with the following URLs: https://www.youtube.com/watch?v=DFYRQ_zQ-gk&feature=featured https://www.youtube.com/watch?v=DFYRQ_zQ-gk http://www.youtube.com/watch?v=DFYRQ_zQ-gk //www.youtube.com/watch?v=DFYRQ_zQ-gk www.youtube.com/watch?v=DFYRQ_zQ-gk https://youtube.com/watch?v=DFYRQ_zQ-gk http://youtube.com/watch?v=DFYRQ_zQ-gk //youtube.com/watch?v=DFYRQ_zQ-gk youtube.com/watch?v=DFYRQ_zQ-gk https://m.youtube.com/watch?v=DFYRQ_zQ-gk http://m.youtube.com/watch?v=DFYRQ_zQ-gk //m.youtube.com/watch?v=DFYRQ_zQ-gk m.youtube.com/watch?v=DFYRQ_zQ-gk https://www.youtube.com/v/DFYRQ_zQ-gk?fs=1&hl=en_US http://www.youtube.com/v/DFYRQ_zQ-gk?fs=1&hl=en_US //www.youtube.com/v/DFYRQ_zQ-gk?fs=1&hl=en_US www.youtube.com/v/DFYRQ_zQ-gk?fs=1&hl=en_US youtube.com/v/DFYRQ_zQ-gk?fs=1&hl=en_US https://www.youtube.com/embed/DFYRQ_zQ-gk?autoplay=1 https://www.youtube.com/embed/DFYRQ_zQ-gk http://www.youtube.com/embed/DFYRQ_zQ-gk //www.youtube.com/embed/DFYRQ_zQ-gk www.youtube.com/embed/DFYRQ_zQ-gk https://youtube.com/embed/DFYRQ_zQ-gk http://youtube.com/embed/DFYRQ_zQ-gk //youtube.com/embed/DFYRQ_zQ-gk youtube.com/embed/DFYRQ_zQ-gk https://youtu.be/DFYRQ_zQ-gk?t=120 https://youtu.be/DFYRQ_zQ-gk http://youtu.be/DFYRQ_zQ-gk //youtu.be/DFYRQ_zQ-gk youtu.be/DFYRQ_zQ-gk https://www.youtube.com/HamdiKickProduction?v=DFYRQ_zQ-gk

For example: /foldera/folderb/filename.txt?query=abc Result: /foldera/folderb/

This query will match count query

On comment in http://requestly.in/documentation/replace-rule/

Search url/link inside text, with/without schema, and with/without path/query