URL decoding: Difference between revisions

 

* &nbsp; The encoded string &nbsp; "<code><nowiki>google.com/search?q=%60Abdu%27l-Bah%C3%A1</nowiki></code>" &nbsp; should revert to the unencoded form &nbsp; "<code><nowiki>google.com/search?q=`Abdu'l-Bahá</nowiki></code>".

<br><br>

 

=={{header|11l}}==

V r = ‘’

V i = 0

 

print(url_decode(‘http%3A%2F%2Ffoo%20bar%2F’))

 

{{out}}

=={{header|ABAP}}==

 

 

DATA: lv_encoded_url TYPE string VALUE 'http%3A%2F%2Ffoo%20bar%2F',

UNESCAPED = lv_decoded_url.

 

 

=={{header|Action!}}==

s(0)==+1

s(s(0))=c

Test("http%3A%2F%2Ffoo%20bar%2F")

Test("http%3A%2F%2Ffoo+bar%2F*_-.html")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/URL_decoding.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{libheader|AWS}}

with Ada.Text_IO; use Ada.Text_IO;

procedure Decode is

Put_Line (AWS.URL.Decode (Encoded));

end Decode;

 

Without external libraries:

 

function Decode (URL : in String) return String;

 

function Decode (URL : in String) return String is

Buffer : String (1 .. URL'Length);

return Buffer (1 .. Filled);

end Decode;

 

Ada.Text_IO;

 

end loop;

end if;

 

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

<br>

For the second task example, this outputs the encoded UTF-8 characters, what you see depends on what you look at it with...

PROC hex value = ( CHAR c )INT: IF c >= "0" AND c <= "9" THEN ABS c - ABS "0"

ELIF c >= "A" AND c <= "F" THEN 10 + ( ABS c - ABS "A" )

# test the url decode procedure #

print( ( url decode( "http%3A%2F%2Ffoo%20bar%2F" ), newline ) );

{{out}}

<pre>

 

=={{header|Apex}}==

<pre>http://foo bar/

google.com/search?q=`Abdu'l-Bahá</pre>

=={{header|AppleScript}}==

{{libheader|AppleScript Toolbox}}

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AutoHotkey}}==

 

=={{header|AWK}}==

# syntax:

awk '

return num + (length(s) ? 16*hex2dec(s) : 0)

} '

{{out}}

<pre>

OR:

 

LC_ALL=C

echo "http%3A%2F%2Ffoo%20bar%2F" | gawk -vRS='%[[:xdigit:]]{2}' '

RT {RT = sprintf("%c",strtonum("0x" substr(RT, 2)))}

{gsub(/+/," ");printf "%s", $0 RT}'

 

{{out}}

 

=={{header|BaCon}}==

 

LOCAL result$

 

PRINT Url_Decode$("http%3A%2F%2Ffoo%20bar%2F")

{{out}}

<pre>

google.com/search?q=`Abdu'l-Bahá

</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

END

IF C% >= 97 IF C% <= 122 MID$(A$,A%,1) = CHR$(C%-32)

NEXT

{{out}}

<pre>

 

=={{header|Bracmat}}==

= decoded hexcode notencoded

. :?decoded

)

& out$(decode$http%3A%2F%2Ffoo%20bar%2F)

{{out}}

<pre>http://foo bar/</pre>

 

=={{header|C}}==

#include <string.h>

 

 

return 0;

 

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

 

 

namespace URLEncode

}

}

 

{{out}}

{{libheader|Poco}}

{{works with|g++}}

#include "Poco/URI.h"

#include <iostream>

std::cout << encoded << " is decoded: " << decoded << " !" << std::endl ;

return 0 ;

{{out}}

<pre>http%3A%2F%2Ffoo%20bar%2F is decoded: http://foo bar/ !</pre>

=={{header|Clojure}}==

 

 

=={{header|CoffeeScript}}==

 

console.log decodeURIComponent "http%3A%2F%2Ffoo%20bar%2F?name=Foo%20Barson"

 

> coffee foo.coffee

http://foo bar/?name=Foo Barson

 

=={{header|Common Lisp}}==

(assert (char= (char string start) #\%))

(if (>= (length string) (+ start 3))

finally (return (apply #'concatenate 'string chunks))))

 

{{out}}

<pre>"http://foo bar/"</pre>

 

=={{header|Crystal}}==

 

puts URI.decode "http%3A%2F%2Ffoo%20bar%2F"

{{out}}

<pre>http://foo bar/

 

=={{header|D}}==

 

void main() {

writeln(decodeComponent("http%3A%2F%2Ffoo%20bar%2F"));

<pre>http://foo bar/</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

begin

Writeln(TIdURI.URLDecode('http%3A%2F%2Ffoo%20bar%2F'));

 

=={{header|Elixir}}==

 

{{out}}

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

let decode uri = Uri.UnescapeDataString(uri)

let main argv =

printfn "%s" (decode "http%3A%2F%2Ffoo%20bar%2F")

 

=={{header|Factor}}==

IN: rosetta-code.url-decoding

 

"http%3A%2F%2Ffoo%20bar%2F"

"google.com/search?q=%60Abdu%27l-Bah%C3%A1"

{{out}}

<pre>

=={{header|Free Pascal}}==

 

var

ch: Char;

pos := pos +1;

end;

 

 

{{trans|Liberty BASIC}}

{{trans|Pascal}}

Const alphanum = "0123456789abcdefghijklmnopqrstuvwxyz"

 

Print "URL decoding '"; url2string(URL); "'"

Sleep

 

=={{header|Frink}}==

While the default is to decode parameters as UTF-8 (which is the W3C recommendation,) the characters may have been encoded in another encoding scheme, and this can be handled correctly.

 

=={{header|Go}}==

 

import (

fmt.Println(u)

}

{{out}}

<pre>

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

 

urlDecode :: String -> Maybe String

 

main :: IO ()

{{out}}

<pre>http://foo bar/</pre>

 

Another approach:

import Data.List.Split (splitOn)

 

-- TEST ------------------------------------------------------------------------

main :: IO ()

{{Out}}

<pre>http://foo bar/</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

 

procedure main()

else move(1)

return c

 

{{libheader|Icon Programming Library}}

Here is an implementation:

 

 

Example use:

 

 

Note that an earlier implementation assumed the j6 implementation of <code>hfd</code> which where hexadecimal letters resulting from <code>hfd</code> were upper case. J8, in contrast, provides a lower case result from hfd. The addition of <code>toupper</code> guarantees the case insensitivity required by [http://tools.ietf.org/html/rfc3986#section-2.1 RFC 3986] regardless of which version of J you are using. As the parenthesized expression containing <code>hfd</code> is only evaluated at definition time, there's no performance penalty from the use of <code>toupper</code>.

Example use:

 

 

=={{header|Java}}==

import java.net.URLDecoder;

}

 

=={{header|JavaScript}}==

 

=={{header|jq}}==

{{works with|jq|1.4}}

If your jq already has "until", then the definition given below may be omitted.

def until(condition; next):

def u: if condition then . else (next|u) end;

else [ $i + 1, .[1] + $in[$i:$i+1] ]

end)

'''Example''':

{{out}}

 

=={{header|Julia}}==

using URIParser

 

 

println(enc, " => ", dcd)

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.net.URLDecoder

val encoded = arrayOf("http%3A%2F%2Ffoo%20bar%2F", "google.com/search?q=%60Abdu%27l-Bah%C3%A1")

for (e in encoded) println(URLDecoder.decode(e, "UTF-8"))

 

{{out}}

 

=={{header|Ksh}}==

url_decode()

{

url_decode "http%3A%2F%2Ffoo%20bar%2F"

url_decode "google.com/search?q=%60Abdu%27l-Bah%C3%A1"

 

{{out}}

=={{header|Lambdatalk}}==

Currently lambdatalk has no builtin primitive for decoding URLs. Let's define it using Javascript.

1) define a new javascript primitive:

{script

 

 

 

=={{header|Lasso}}==

-> http://foo bar/

 

=={{header|Liberty BASIC}}==

dim lookUp$( 256)

 

next j

end function

Supplied URL 'http%3A%2F%2Ffoo%20bar%2F'

As string 'http://foo bar/'

 

=={{header|Lingo}}==

-- URL decodes a string

-- @param {string} str

ba.position = 1

return ba.readRawString(ba.length)

{{Out}}

<pre>

 

=={{header|LiveCode}}==

 

=={{header|Lua}}==

return string.char(tonumber(hex,16))

end

 

-- will print "http://foo bar/"

 

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

 

b$=chr$(a$) revert bytes to words adding zeroes after each character

Module CheckIt {

Function decodeUrl$(a$) {

}

CheckIt

 

=={{header|Maple}}==

 

{{Out}}

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

StringReplace[url, "%" ~~ x_ ~~ y_ :> FromDigits[x ~~ y, 16]] //.

StringExpression[x___, Longest[n__Integer], y___] :>

Example use:

{{out}}

<pre>http://foo bar/</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

u = '';

k = 1;

end

end

Usage:

<pre>octave:3> urldecoding('http%3A%2F%2Ffoo%20bar%2F')

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

 

return decoded

 

{{out}}

 

=={{header|NewLISP}}==

;; (source http://www.newlisp.org/index.cgi?page=Code_Snippets)

(define (url-decode url (opt nil))

(replace "%([0-9a-f][0-9a-f])" url (pack "b" (int $1 0 16)) 1))

 

 

=={{header|Nim}}==

 

 

{{out}}

=={{header|Oberon-2}}==

{{works with|oo2c}}

MODULE URLDecoding;

IMPORT

Out.String(URI.Unescape("google.com/search?q=%60Abdu%27l-Bah%C3%A1"));Out.Ln;

END URLDecoding.

{{out}}

<pre>

 

=={{header|Objeck}}==

class UrlDecode {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|Objective-C}}==

NSString *normal = [encoded stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

{{works with|Mac OS X|10.9+}}{{works with|iOS|7+}}

NSString *normal = [encoded stringByRemovingPercentEncoding];

 

=={{header|OCaml}}==

Using the library [http://projects.camlcity.org/projects/ocamlnet.html ocamlnet] from the interactive loop:

 

# #use "topfind";;

# #require "netstring";;

 

# Netencoding.Url.decode "http%3A%2F%2Ffoo%20bar%2F" ;;

 

=={{header|ooRexx}}==

While the implementation shown for [[#REXX|Rexx]] will also work with ooRexx, this version uses ooRexx syntax to invoke the built-in functions.

X = 0

url. = ''

End e_

 

 

{{out}}

=={{header|Perl}}==

 

my $s = shift;

$s =~ tr/\+/ /;

 

print urldecode('http%3A%2F%2Ffoo+bar%2F')."\n";

 

use strict ;

use URI::Escape ;

my $encoded = "http%3A%2F%2Ffoo%20bar%2F" ;

my $unencoded = uri_unescape( $encoded ) ;

 

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\decode_url.exw

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

{{Out}}

<pre>

 

=={{header|PHP}}==

$encoded = "http%3A%2F%2Ffoo%20bar%2F";

$unencoded = rawurldecode($encoded);

echo "The unencoded string is $unencoded !\n";

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

void main()

{

}

}

{{Out}}

<pre>

 

=={{header|PowerShell}}==

[System.Web.HttpUtility]::UrlDecode("http%3A%2F%2Ffoo%20bar%2F")

{{Out}}

<pre>

 

=={{header|PureBasic}}==

 

 

=={{header|Python}}==

#Python 2.X

import urllib

from urllib.parse import unquote

print(unquote('http%3A%2F%2Ffoo%20bar%2F'))

 

=={{header|R}}==

 

 

=={{header|Racket}}==

 

#lang racket

(require net/uri-codec)

(uri-decode "http%3A%2F%2Ffoo%20bar%2F")

 

=={{header|Raku}}==

(formerly Perl 6)

google.com/search?q=%60Abdu%27l-Bah%C3%A1 >;

 

say .subst( :g,

{ Blob.new((:16(~$_) for $0)).decode }

{{out}}

<pre>http://foo bar/

=={{header|Red}}==

 

== "http://foo bar/"

>> dehex "google.com/search?q=%60Abdu%27l-Bah%C3%A1"

 

=={{header|Retro}}==

This is provided by the '''casket''' library (used for web app development).

 

 

{{

}}

 

 

=={{header|REXX}}==

{{Trans|ooRexx}}

Tested with the ooRexx and Regina interpreters.

 

Do

End

Exit

 

{{out}}

===version 2===

This REXX version is identical to version 1, but with superfluous and dead code removed.

url.1='http%3A%2F%2Ffoo%20bar%2F'

url.2='mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E'

end /*while*/

 

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}}

 

===version 3===

This REXX version is a shorter version of version 2.

url. =

url.1='http%3A%2F%2Ffoo%20bar%2F'

else URL= URL'%'code

end /*until*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}}

 

Use any one of <code>CGI.unescape</code> or <code>URI.decode_www_form_component</code>. These methods also convert "+" to " ".

 

puts CGI.unescape("http%3A%2F%2Ffoo%20bar%2F")

 

{{works with|Ruby|1.9.2}}

puts URI.decode_www_form_component("http%3A%2F%2Ffoo%20bar%2F")

 

<code>URI.unescape</code> (alias <code>URI.unencode</code>) still works. <code>URI.unescape</code> is obsolete since Ruby 1.9.2 because of problems with its sibling <code>URI.escape</code>.

 

=={{header|Rust}}==

const INPUT2: &str = "google.com/search?q=%60Abdu%27l-Bah%C3%A1";

 

println!("{}", decode(INPUT1));

println!("{}", decode(INPUT2));

{{out}}

<pre>

 

=={{header|Scala}}==

import scala.compat.Platform.currentTime

 

 

println(s"Successfully completed without errors. [total ${currentTime - executionStart} ms]")

 

=={{header|Seed7}}==

works like ''fromPercentEncoded'' and additionally decodes '+' with a space.

Both functions return byte sequences.

include "encoding.s7i";

 

writeln(fromPercentEncoded("http%3A%2F%2Ffoo%20bar%2F"));

writeln(fromUrlEncoded("http%3A%2F%2Ffoo+bar%2F"));

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

str.gsub!('+', ' ');

str.gsub!(/\%([A-Fa-f0-9]{2})/, {|a| 'C'.pack(a.hex)});

}

 

 

=={{header|Swift}}==

 

let encoded = "http%3A%2F%2Ffoo%20bar%2F"

if let normal = encoded.stringByReplacingPercentEscapesUsingEncoding(NSUTF8StringEncoding) {

println(normal)

 

=={{header|Tcl}}==

This code is careful to ensure that any untoward metacharacters in the input string still do not cause any problems.

set specialMap {"[" "%5B" "]" "%5D"}

set seqRE {%([0-9a-fA-F]{2})}

set modStr [regsub -all $seqRE [string map $specialMap $str] $replacement]

return [encoding convertfrom utf-8 [subst -nobackslash -novariable $modStr]]

Demonstrating:

{{out}}

<pre>http://foo bar/</pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

url_encoded="http%3A%2F%2Ffoo%20bar%2F"

PRINT "encoded: ", url_encoded

PRINT "decoded: ", url_decoded

{{out}}

<pre>

{{works with|ksh}}

 

 

Example:

 

http://foo bar/

 

urldecode google.com/search?q=%60Abdu%27l-Bah%C3%A1

google.com/search?q=`Abdu'l-Bahároot@

 

{

typeset encoded=$1 decoded= rest= c= c1= c2=

fi

}

 

=={{header|VBScript}}==

Dim regEx

Set regEx = New RegExp

url = "http%3A%2F%2Ffoo%20bar%C3%A8%2F"

WScript.Echo "Encoded URL: " & url & vbCrLf &_

{{out}}

Decoded URL: http://foo barè/</pre>

 

fn main() {

for escaped in [

println(u)

}

{{out}}

<pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var urlDecode = Fn.new { |enc|

"google.com/search?q=\%60Abdu\%27l-Bah\%C3\%A1"

]

 

{{out}}

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

];

 

 

{{out}}

=={{header|Yabasic}}==

{{trans|Phix}}

local res$, ch$

 

print decode_url$("http%3A%2F%2Ffoo%20bar%2F")

 

=={{header|zkl}}==

fcn(c){ if(c=="%") return(Void.Read,2); return(Void.Skip,c) },// %-->read 2 chars else pass through

{{out}}

<pre>http://foo bar/</pre>

or use libCurl:

{{out}}<pre>http://foo bar/</pre>