URL parser: Difference between revisions

:* &nbsp; <nowiki> urn:oasis:names:specification:docbook:dtd:xml:4.1.2 </nowiki>

<br><br>

 

=={{header|ALGOL 68}}==

Uses the URI parser here: [[URL_parser/URI_parser_ALGOL68]].

 

 

PROC test uri parser = ( STRING uri )VOID:

; test uri parser( "https://bob:pass@example.com/place" )

; test uri parser( "http://example.com/?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64" )

{{out}}

<pre>

</pre>

 

 

 

 

 

 

=={{header|C sharp|C#}}==

 

 

namespace RosettaUrlParse

}

}

 

=={{header|Elixir}}==

"foo://example.com:8042/over/there?name=ferret#nose",

"urn:example:animal:ferret:nose",

IO.puts "\n#{str}"

IO.inspect URI.parse(str)

 

{{out}}

<li>The System.URI class does some "Scheme-Based Normalization" (c/f rfc3986 section 6.2.3), i. e. it knows about certain

defaults for some schemes. With the test data this shows with the port numbers for http, ftp, ldap, mailto.</li></ul>

open System.Text.RegularExpressions

 

writeline " query:" (if u.Query.Length > 0 then u.Query.Substring(1) else "")

writeline " fragment:" (if u.Fragment.Length > 0 then u.Fragment.Substring(1) else "")

{{out}}

<pre style="height:3cm">

This uses Go's standard [https://golang.org/pkg/net/url/ <tt>net/url</tt>] package.

The [https://golang.org/src/net/url/url.go source code] for this package (excluding tests) is in a single file of ~720 lines.

 

import (

fmt.Println(" Fragment:", u.Fragment)

}

{{out}}

<pre>

 

Test:

 

[

| query = ${u.query}

| fragment = ${u.fragment}""".stripMargin()

 

Output:

Example uses [https://hackage.haskell.org/package/network-uri <tt>network-uri</tt>] package:

 

 

import Data.Foldable (for_)

Nothing -> return ()

Just fragment -> putStrLn $ " fragment = " ++ fragment

{{out}}

<pre>

Implementation:

 

({. ; ] }.~ 1+[)~ i.&m

)

export=. ;:'scheme user creds host port path query fragment'

(#~ 0<#@>@{:"1) (,. do each) export

 

Task examples:

 

┌────────┬─────────────┐

│scheme │foo │

├──────┼───────────────────────────────────────────────┤

│path │oasis:names:specification:docbook:dtd:xml:4.1.2│

 

Note that the <code>path</code> of the example <code>jdbc</code> uri is itself a uri which may be parsed:

 

┌──────┬──────────┐

│scheme│mysql │

├──────┼──────────┤

│path │/sakila │

 

Also, examples borrowed from the <code>go</code> implementation:

 

┌──────┬───────────┐

│scheme│ssh │

│ ││a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64││

│ │└─────────────────────────────────────────┘│

 

Note that escape decoding is left to the consumer (as well as decoding things like '+' as a replacement for the space character and determining the absolute significance of relative paths and the details of ip address parsing and so on...). This seems like a good match to the hierarchical nature of uri parsing. See [[URL_decoding#J|URL decoding]] for an implementation of escape decoding.

 

=={{header|Java}}==

 

 

}

}

}

 

=={{header|JavaScript}}==

Here is an example, tested against the JavaScript engines of current versions of Chrome and Safari, of taking this 'Gordian knot' approach to the task:

 

 

var e = document.createElement('a'),

"https://bob:pass@example.com/place",

"http://example.com/?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64"

 

Results of applying this approach in the JavaScript of Safari 8

{

"hash": "#nose",

"search": "?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64"

}

 

=={{header|Julia}}==

This solution uses Julia's [https://github.com/JuliaWeb/URIParser.jl URIParser] package. The <code>detailview</code> function shows all of the non-empty components of the <code>URI</code> object created by this parser. No attempt is made to further parse more complex components, e.g. query or userinfo. Error detection is limited to indicating whether a string is parsable as a URI and providing a hint as to whether the <code>URI</code> is valid (according to this package's <code>isvalid</code> function).

const FIELDS = names(URI)

 

println(detailview(uri))

end

 

{{out}}

=={{header|Kotlin}}==

Although the java.net.URL class can parse urls just fine, unfortunately (as far as this task is concerned) the constructor throws an exception if it does not recognize the scheme (or 'protocol' as it calls it). To deal with unrecognized protocols such as 'foo', we therefore need to replace them with a valid protocol such as 'http' to trick the URL class into parsing them properly:

 

import java.net.URL

)

for (url in urls) parseUrl(url)

 

{{out}}

{{libheader|LuaSocket}}

 

 

local tests = {

io.write('\n')

end

{{out}}

<pre>

path: oasis:names:specification:docbook:dtd:xml:4.1.2

</pre>

=={{header|M2000 Interpreter}}==

===Using M2000 script to parse URL===

Module checkit {

any=lambda (z$)->{=lambda z$ (a$)->instr(z$,a$)>0}

}

Checkit

{{out}}

<pre style="height:30ex;overflow:scroll">

 

===Using an internal function (variation of String$())===

module Checkit {

Stack New {

}

Checkit

{{out}}

<pre style="height:30ex;overflow:scroll">

</pre >

 

{{out}}

<pre><|"Scheme" -> "foo", "User" -> None, "Domain" -> "example.com",

 

=={{header|Nim}}==

 

 

proc printUri(url: string) =

echo &"\t Opaque: {res.opaque}"

 

"urn:example:animal:ferret:nose",

"jdbc:mysql://test_user:ouupppssss@localhost:3306/sakila?profileSQL=true",

 

for url in urls:

{{out}}

<pre>foo://example.com:8042/over/there?name=ferret#nose

=={{header|Objeck}}==

 

 

class Test {

};

}

 

{{out}}

=={{header|Perl}}==

You can use the URI module from CPAN to parse URIs. Note that the output is a bit different: for example, you don't get the host from the <code>foo://</code> scheme, as host is only valid for schemes that define it.

use warnings;

use strict;

}

 

{{out}}

<pre>foo://example.com:8042/over/there?name=ferret#nose

scheme urn

path oasis:names:specification:docbook:dtd:xml:4.1.2</pre>

 

=={{header|Phix}}==

{{Out}}

<pre>

query : "a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64"

</pre>

 

=={{header|PowerShell}}==

I was confused about the '''Path''' parameter. PowerShell returns '''LocalPath''', '''AbsolutePath''' and '''AbsoluteUri'''; I defaulted to '''LocalPath''', but all properties are returned in the <code>$parsedUrls</code> variable.

function Get-ParsedUrl

{

}

}

[string[]]$urls = @'

foo://example.com:8042/over/there?name=ferret#nose

 

$parsedUrls | Select-Object -Property Scheme, Port, Domain, Path, Query, Fragment | Format-Table

{{Out}}

<pre>

=={{header|Python}}==

Links to Python Documentation: v2: [https://docs.python.org/2/library/urlparse.html#module-urlparse], v3: [https://docs.python.org/3.4/library/urllib.parse.html]

 

url = up.urlparse('http://user:pass@example.com:8081/path/file.html;params?query1=1#fragment')

print('url.username = ', url.username)

print('url.password = ', url.password)

{{out}}

<pre>

url.password = pass

</pre>

=={{header|R}}==

library(urltools)

 

cat("\n")

}

{{out}}

<pre>

parameter : a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64

</pre>

=={{header|Racket}}==

Links: [http://docs.racket-lang.org/net/url.html?q=url#%28def._%28%28lib._net%2Furl-structs..rkt%29._url%29%29 <code>url</code> structure in Racket documentation].

 

(require racket/match net/url)

(define (debug-url-string U)

"tel:+1-816-555-1212"

"telnet://192.0.2.16:80/"

 

{{out}}

path bits: ("oasis:names:specification:docbook:dtd:xml:4.1.2")</pre>

 

 

=={{header|Ruby}}==

 

As you can see in the output below, the URI library doesn't parse all of these as recommended.

 

test_cases = [

puts " #{attr.rjust(8)} = #{uri.send(attr)}" if uri.send(attr)

end

{{out}}

<pre>foo://example.com:8042/over/there?name=ferret#nose

path = /

query = a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64</pre>

 

=={{header|Scala}}==

 

object WebAddressParser extends App {

} catch { case ex: Throwable => println('\u2718') }

}

{{Out}}See it in running in your browser by [https://scastie.scala-lang.org/GZdtfkhfRsa9QPKZQ7W4XQ Scastie (JVM)].

=={{header|Tcl}}==

 

The <tt>uri</tt> package doesn't presently handle IPv6 syntx as used in the example: a bug and patch will be submitted presently ..

 

package require uri::urn

 

puts \n$uri

pdict [parse_uri $uri]

 

{{out}}

 

=={{header|VBScript}}==

Function parse_url(url)

parse_url = "URL: " & url

WScript.StdOut.WriteLine "-------------------------------"

WScript.StdOut.WriteLine parse_url("this code is messy, long, and needs a makeover!!!")

 

{{Out}}

URL: this code is messy, long, and needs a makeover!!!

Invalid!!!

</pre>