URL decoding
You are encouraged to solve this task according to the task description, using any language you may know.
This task (the reverse of URL encoding and distinct from URL parser) is to provide a function or mechanism to convert an URL-encoded string into its original unencoded form.
- Test cases
- The encoded string "
http%3A%2F%2Ffoo%20bar%2F
" should be reverted to the unencoded form "http://foo bar/
".
- The encoded string "
google.com/search?q=%60Abdu%27l-Bah%C3%A1
" should revert to the unencoded form "google.com/search?q=`Abdu'l-Bahá
".
ABAP
<lang ABAP>REPORT Z_DECODE_URL.
DATA: lv_encoded_url TYPE string VALUE 'http%3A%2F%2Ffoo%20bar%2F',
lv_decoded_url TYPE string.
CALL METHOD CL_HTTP_UTILITY=>UNESCAPE_URL
EXPORTING ESCAPED = lv_encoded_url RECEIVING UNESCAPED = lv_decoded_url.
WRITE: 'Encoded URL: ', lv_encoded_url, /, 'Decoded URL: ', lv_decoded_url.</lang>
Ada
<lang Ada>with AWS.URL; with Ada.Text_IO; use Ada.Text_IO; procedure Decode is
Encoded : constant String := "http%3A%2F%2Ffoo%20bar%2F";
begin
Put_Line (AWS.URL.Decode (Encoded));
end Decode; </lang>
Without external libraries:
<lang Ada>package URL is
function Decode (URL : in String) return String;
end URL;</lang>
<lang Ada>package body URL is
function Decode (URL : in String) return String is Buffer : String (1 .. URL'Length); Filled : Natural := 0; Position : Positive := URL'First; begin while Position in URL'Range loop Filled := Filled + 1; case URL (Position) is when '+' => Buffer (Filled) := ' '; Position := Position + 1; when '%' => Buffer (Filled) := Character'Val (Natural'Value ("16#" & URL (Position + 1 .. Position + 2) & "#")); Position := Position + 3; when others => Buffer (Filled) := URL (Position); Position := Position + 1; end case; end loop;
return Buffer (1 .. Filled); end Decode;
end URL;</lang>
<lang Ada>with Ada.Command_Line,
Ada.Text_IO;
with URL;
procedure Test_URL_Decode is
use Ada.Command_Line, Ada.Text_IO;
begin
if Argument_Count = 0 then Put_Line (URL.Decode ("http%3A%2F%2Ffoo%20bar%2F")); else for I in 1 .. Argument_Count loop Put_Line (URL.Decode (Argument (I))); end loop; end if;
end Test_URL_Decode;</lang>
ALGOL 68
Note: See the discussion page re displaying the results (which is mostly focused on the AWK solution but will apply elsewhere too).
For the second task example, this outputs the encoded UTF-8 characters, what you see depends on what you look at it with...
<lang algol68># returns c decoded as a hex digit #
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" ) ELSE 10 + ( ABS c - ABS "a" ) FI;
- returns the URL encoded string decoded - minimal error handling #
PROC url decode = ( STRING encoded )STRING:
BEGIN [ LWB encoded : UPB encoded ]CHAR result; INT result pos := LWB encoded; INT pos := LWB encoded; INT max pos := UPB encoded; INT max encoded := max pos - 3; WHILE pos <= UPB encoded DO IF encoded[ pos ] /= "%" AND pos <= max encoded THEN # not a coded character # result[ result pos ] := encoded[ pos ]; pos +:= 1 ELSE # have an encoded character # result[ result pos ] := REPR ( ( 16 * hex value( encoded[ pos + 1 ] ) ) + hex value( encoded[ pos + 2 ] ) ); pos +:= 3 FI; result pos +:= 1 OD; result[ LWB result : result pos - 1 ] END # url decode # ;
- test the url decode procedure #
print( ( url decode( "http%3A%2F%2Ffoo%20bar%2F" ), newline ) ); print( ( url decode( "google.com/search?q=%60Abdu%27l-Bah%C3%A1" ), newline ) )</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
Apex
<lang apex>EncodingUtil.urlDecode('http%3A%2F%2Ffoo%20bar%2F', 'UTF-8'); EncodingUtil.urlDecode('google.com/search?q=%60Abdu%27l-Bah%C3%A1', 'UTF-8');</lang>
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
AppleScript
<lang AppleScript>AST URL decode "google.com/search?q=%60Abdu%27l-Bah%C3%A1"</lang>
Arturo
<lang arturo>url1: "http%3A%2F%2Ffoo%20bar%2F" print [decodeUrl url1]
url2: "google.com/search?q=%60Abdu%27l-Bah%C3%A1" print [decodeUrl url2]</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
AutoHotkey
<lang AutoHotkey>encURL := "http%3A%2F%2Ffoo%20bar%2F" SetFormat, Integer, hex Loop Parse, encURL
If A_LoopField = `% reading := 2, read := "" else if reading { read .= A_LoopField, --reading if not reading out .= Chr("0x" . read) } else out .= A_LoopField
MsgBox % out ; http://foo bar/ </lang>
AWK
<lang AWK>
- syntax:
awk ' BEGIN {
str = "http%3A%2F%2Ffoo%20bar%2F" # "http://foo bar/" printf("%s\n",str) len=length(str) for (i=1;i<=len;i++) { if ( substr(str,i,1) == "%") { L = substr(str,1,i-1) # chars to left of "%" M = substr(str,i+1,2) # 2 chars to right of "%" R = substr(str,i+3) # chars to right of "%xx" str = sprintf("%s%c%s",L,hex2dec(M),R) } } printf("%s\n",str) exit(0)
} function hex2dec(s, num) {
num = index("0123456789ABCDEF",toupper(substr(s,length(s)))) - 1 sub(/.$/,"",s) return num + (length(s) ? 16*hex2dec(s) : 0)
} ' </lang>
- Output:
http%3A%2F%2Ffoo%20bar%2F http://foo bar/
BaCon
<lang freebasic>FUNCTION Url_Decode$(url$)
LOCAL result$
SPLIT url$ BY "%" TO item$ SIZE total FOR x = 1 TO total-1 result$ = result$ & CHR$(DEC(LEFT$(item$[x], 2))) & MID$(item$[x], 3) NEXT RETURN item$[0] & result$
END FUNCTION
PRINT Url_Decode$("http%3A%2F%2Ffoo%20bar%2F") PRINT Url_Decode$("google.com/search?q=%60Abdu%27l-Bah%C3%A1")</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
BBC BASIC
<lang bbcbasic> PRINT FNurldecode("http%3A%2F%2Ffoo%20bar%2F")
END DEF FNurldecode(url$) LOCAL i% REPEAT i% = INSTR(url$, "%", i%+1) IF i% THEN url$ = LEFT$(url$,i%-1) + \ \ CHR$EVAL("&"+FNupper(MID$(url$,i%+1,2))) + \ \ MID$(url$,i%+3) ENDIF UNTIL i% = 0 = url$ DEF FNupper(A$) LOCAL A%,C% FOR A% = 1 TO LEN(A$) C% = ASCMID$(A$,A%) IF C% >= 97 IF C% <= 122 MID$(A$,A%,1) = CHR$(C%-32) NEXT = A$</lang>
- Output:
http://foo bar/
Bracmat
<lang bracmat>( ( decode
= decoded hexcode notencoded . :?decoded & whl ' ( @(!arg:?notencoded "%" (% %:?hexcode) ?arg) & !decoded !notencoded chr$(x2d$!hexcode):?decoded ) & str$(!decoded !arg) ) & out$(decode$http%3A%2F%2Ffoo%20bar%2F)
);</lang>
- Output:
http://foo bar/
C
<lang c>#include <stdio.h>
- include <string.h>
inline int ishex(int x) { return (x >= '0' && x <= '9') || (x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F'); }
int decode(const char *s, char *dec) { char *o; const char *end = s + strlen(s); int c;
for (o = dec; s <= end; o++) { c = *s++; if (c == '+') c = ' '; else if (c == '%' && ( !ishex(*s++) || !ishex(*s++) || !sscanf(s - 2, "%2x", &c))) return -1;
if (dec) *o = c; }
return o - dec; }
int main() { const char *url = "http%3A%2F%2ffoo+bar%2fabcd"; char out[strlen(url) + 1];
printf("length: %d\n", decode(url, 0)); puts(decode(url, out) < 0 ? "bad string" : out);
return 0; }</lang>
C#
<lang csharp>using System;
namespace URLEncode {
internal class Program { private static void Main(string[] args) { Console.WriteLine(Decode("http%3A%2F%2Ffoo%20bar%2F")); }
private static string Decode(string uri) { return Uri.UnescapeDataString(uri); } }
}</lang>
- Output:
http://foo bar/
C++
<lang cpp>#include <string>
- include "Poco/URI.h"
- include <iostream>
int main( ) {
std::string encoded( "http%3A%2F%2Ffoo%20bar%2F" ) ; std::string decoded ; Poco::URI::decode ( encoded , decoded ) ; std::cout << encoded << " is decoded: " << decoded << " !" << std::endl ; return 0 ;
}</lang>
- Output:
http%3A%2F%2Ffoo%20bar%2F is decoded: http://foo bar/ !
Caché ObjectScript
USER>Write $ZConvert("http%3A%2F%2Ffoo%20bar%2F", "I", "URL") http://foo bar/
Clojure
<lang clojure>(java.net.URLDecoder/decode "http%3A%2F%2Ffoo%20bar%2F")</lang>
CoffeeScript
<lang coffeescript> console.log decodeURIComponent "http%3A%2F%2Ffoo%20bar%2F?name=Foo%20Barson" </lang>
<lang> > coffee foo.coffee http://foo bar/?name=Foo Barson </lang>
Common Lisp
<lang lisp>(defun decode (string &key start)
(assert (char= (char string start) #\%)) (if (>= (length string) (+ start 3)) (multiple-value-bind (code pos) (parse-integer string :start (1+ start) :end (+ start 3) :radix 16 :junk-allowed t) (if (= pos (+ start 3)) (values (code-char code) pos) (values #\% (1+ start)))) (values #\% (1+ start))))
(defun url-decode (url)
(loop with start = 0 for pos = (position #\% url :start start) collect (subseq url start pos) into chunks when pos collect (multiple-value-bind (decoded next) (decode url :start pos) (setf start next) (string decoded)) into chunks while pos finally (return (apply #'concatenate 'string chunks))))
(url-decode "http%3A%2F%2Ffoo%20bar%2F")</lang>
- Output:
"http://foo bar/"
D
<lang d>import std.stdio, std.uri;
void main() {
writeln(decodeComponent("http%3A%2F%2Ffoo%20bar%2F"));
}</lang>
http://foo bar/
Delphi
<lang Delphi>program URLEncoding;
{$APPTYPE CONSOLE}
uses IdURI;
begin
Writeln(TIdURI.URLDecode('http%3A%2F%2Ffoo%20bar%2F'));
end.</lang>
Elixir
<lang elixir>IO.inspect URI.decode("http%3A%2F%2Ffoo%20bar%2F") IO.inspect URI.decode("google.com/search?q=%60Abdu%27l-Bah%C3%A1")</lang>
- Output:
"http://foo bar/" "google.com/search?q=`Abdu'l-Bahá"
Erlang
Built in.
34> http_uri:decode("http%3A%2F%2Ffoo%20bar%2F"). "http://foo bar/"
F#
<lang fsharp>open System
let decode uri = Uri.UnescapeDataString(uri)
[<EntryPoint>] let main argv =
printfn "%s" (decode "http%3A%2F%2Ffoo%20bar%2F") 0</lang>
Factor
<lang factor>USING: io kernel urls.encoding ; IN: rosetta-code.url-decoding
"http%3A%2F%2Ffoo%20bar%2F" "google.com/search?q=%60Abdu%27l-Bah%C3%A1" [ url-decode print ] bi@</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
Free Pascal
<lang pascal>function urlDecode(data: String): AnsiString; var
ch: Char; pos, skip: Integer;
begin
pos := 0; skip := 0; Result := ;
for ch in data do begin if skip = 0 then begin if (ch = '%') and (pos < data.length -2) then begin skip := 2; Result := Result + AnsiChar(Hex2Dec('$' + data[pos+2] + data[pos+3]));
end else begin Result := Result + ch; end;
end else begin skip := skip - 1; end; pos := pos +1; end;
end;</lang>
Go
<lang go>package main
import ( "fmt" "log" "net/url" )
func main() { for _, escaped := range []string{ "http%3A%2F%2Ffoo%20bar%2F", "google.com/search?q=%60Abdu%27l-Bah%C3%A1", } { u, err := url.QueryUnescape(escaped) if err != nil { log.Println(err) continue } fmt.Println(u) } }</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
Groovy
<lang groovy>assert URLDecoder.decode('http%3A%2F%2Ffoo%20bar%2F') == 'http://foo bar/'</lang>
Haskell
<lang Haskell>import qualified Data.Char as Char
urlDecode :: String -> Maybe String urlDecode [] = Just [] urlDecode ('%':xs) =
case xs of (a:b:xss) -> urlDecode xss >>= return . ((Char.chr . read $ "0x" ++ [a,b]) :) _ -> Nothing
urlDecode ('+':xs) = urlDecode xs >>= return . (' ' :) urlDecode (x:xs) = urlDecode xs >>= return . (x :)
main :: IO () main = putStrLn . maybe "Bad decode" id $ urlDecode "http%3A%2F%2Ffoo%20bar%2F"</lang>
- Output:
http://foo bar/
Another approach: <lang haskell>import Data.Char (chr) import Data.List.Split (splitOn)
deCode :: String -> String deCode url =
let ps = splitOn "%" url in concat $ head ps : ((\(a, b) -> (chr . read) (mappend "0x" a) : b) <$> (splitAt 2 <$> tail ps))
-- TEST ------------------------------------------------------------------------ main :: IO () main = putStrLn $ deCode "http%3A%2F%2Ffoo%20bar%2F"</lang>
- Output:
http://foo bar/
Icon and Unicon
<lang Icon>link hexcvt
procedure main() ue := "http%3A%2F%2Ffoo%20bar%2F" ud := decodeURL(ue) | stop("Improperly encoded string ",image(ue)) write("encoded = ",image(ue)) write("decoded = ",image(ue)) end
procedure decodeURL(s) #: decode URL/URI encoded data static de initial { # build lookup table for everything
de := table() every de[hexstring(ord(c := !string(&ascii)),2)] := c }
c := "" s ? until pos(0) do # decode every %xx or fail
c ||:= if ="%" then \de[move(2)] | fail else move(1)
return c end</lang>
- Output:
encoded = "http%3A%2F%2Ffoo%20bar%2F" decoded = "http://foo bar/"
J
J does not have a native urldecode (until version 7 when the jhs
ide addon includes a jurldecode).
Here is an implementation:
<lang j>require'strings convert' urldecode=: rplc&(~.,/;"_1&a."2(,:tolower)'%',.toupper hfd i.#a.)</lang>
Example use:
<lang j> urldecode 'http%3A%2F%2Ffoo%20bar%2F' http://foo bar/</lang>
Note that an earlier implementation assumed the j6 implementation of hfd
which where hexadecimal letters resulting from hfd
were upper case. J8, in contrast, provides a lower case result from hfd. The addition of toupper
guarantees the case insensitivity required by RFC 3986 regardless of which version of J you are using. As the parenthesized expression containing hfd
is only evaluated at definition time, there's no performance penalty from the use of toupper
.
Example use:
<lang j> urldecode 'google.com/search?q=%60Abdu%27l-Bah%C3%A1' google.com/search?q=`Abdu'l-Bahá</lang>
Java
<lang java>import java.io.UnsupportedEncodingException; import java.net.URLDecoder;
public class Main {
public static void main(String[] args) throws UnsupportedEncodingException { String encoded = "http%3A%2F%2Ffoo%20bar%2F"; String normal = URLDecoder.decode(encoded, "utf-8"); System.out.println(normal); }
}</lang>
- Output:
http://foo bar/
JavaScript
<lang javascript>decodeURIComponent("http%3A%2F%2Ffoo%20bar%2F")</lang>
jq
If your jq already has "until", then the definition given below may be omitted. <lang jq># Emit . and stop as soon as "condition" is true. def until(condition; next):
def u: if condition then . else (next|u) end; u;
def url_decode:
# The helper function converts the input string written in the given # "base" to an integer def to_i(base): explode | reverse | map(if 65 <= . and . <= 90 then . + 32 else . end) # downcase | map(if . > 96 then . - 87 else . - 48 end) # "a" ~ 97 => 10 ~ 87 | reduce .[] as $c # base: [power, ans] ([1,0]; (.[0] * base) as $b | [$b, .[1] + (.[0] * $c)]) | .[1];
. as $in | length as $length | [0, ""] # i, answer | until ( .[0] >= $length; .[0] as $i | if $in[$i:$i+1] == "%" then [ $i + 3, .[1] + ([$in[$i+1:$i+3] | to_i(16)] | implode) ] else [ $i + 1, .[1] + $in[$i:$i+1] ] end) | .[1]; # answer</lang>
Example: <lang jq>"http%3A%2F%2Ffoo%20bar%2F" | url_decode</lang>
- Output:
<lang sh> "http://foo bar/"</lang>
Julia
<lang Julia> using URIParser
enc = "http%3A%2F%2Ffoo%20bar%2F"
dcd = unescape(enc)
println(enc, " => ", dcd) </lang>
- Output:
http%3A%2F%2Ffoo%20bar%2F => http://foo bar/
Kotlin
<lang scala>// version 1.1.2
import java.net.URLDecoder
fun main(args: Array<String>) {
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"))
}</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
Lambdatalk
Currently lambdatalk has no builtin primitive for decoding URLs. Let's define it using Javascript. <lang scheme> 1) define a new javascript primitive: {script
LAMBDATALK.DICT['decodeURIComponent'] = function() { return decodeURIComponent( arguments[0].trim() ); };
}
2) and use it: {decodeURIComponent http%3A%2F%2Ffoo%20bar%2F} -> http://foo bar/
</lang>
Lasso
<lang Lasso>bytes('http%3A%2F%2Ffoo%20bar%2F') -> decodeurl</lang> -> http://foo bar/
Liberty BASIC
<lang lb>
dim lookUp$( 256)
for i =0 to 256 lookUp$( i) ="%" +dechex$( i) next i
url$ ="http%3A%2F%2Ffoo%20bar%2F"
print "Supplied URL '"; url$; "'" print "As string '"; url2string$( url$); "'"
end
function url2string$( i$)
for j =1 to len( i$) c$ =mid$( i$, j, 1) if c$ ="%" then nc$ =chr$( hexdec( mid$( i$, j +1, 2))) url2string$ =url2string$ +nc$ j =j +2 else url2string$ =url2string$ +c$ end if next j
end function </lang>
Supplied URL 'http%3A%2F%2Ffoo%20bar%2F' As string 'http://foo bar/'
Lingo
<lang Lingo>---------------------------------------- -- URL decodes a string -- @param {string} str -- @return {string}
on urldecode (str)
res = "" ba = bytearray() len = str.length repeat with i = 1 to len c = str.char[i] if (c = "%") then -- fastest hex-to-dec conversion hack based on Lingo's rgb object ba.writeInt8(rgb(str.char[i+1..i+2]).blue) i = i + 2 else if (c = "+") then ba.writeInt8(32) else ba.writeInt8(chartonum(c)) end if end repeat ba.position = 1 return ba.readRawString(ba.length)
end</lang> <lang Lingo>put urldecode("http%3A%2F%2Ffoo%20bar%2F") put urldecode("google.com/search?q=%60Abdu%27l-Bah%C3%A1")</lang>
- Output:
-- "http://foo bar/" -- "google.com/search?q=`Abdu'l-Bahá"
LiveCode
<lang LiveCode>put urlDecode("http%3A%2F%2Ffoo%20bar%2F") & cr & \
urlDecode("google.com/search?q=%60Abdu%27l-Bah%C3%A1")</lang>Results<lang>http://foo bar/
google.com/search?q=`Abdu'l-Bah√°</lang>
Lua
<lang lua>function decodeChar(hex) return string.char(tonumber(hex,16)) end
function decodeString(str) local output, t = string.gsub(str,"%%(%x%x)",decodeChar) return output end
-- will print "http://foo bar/" print(decodeString("http%3A%2F%2Ffoo%20bar%2F"))</lang>
M2000 Interpreter
Function Len(string) return length in words, so a value 1.5 means 3 bytes
We can add strings with half word at the end of a series of words.
A$=str$("A") has a length of 0.5
b$=chr$(a$) revert bytes to words adding zeroes after each character <lang M2000 Interpreter> Module CheckIt {
Function decodeUrl$(a$) { DIM a$() a$()=Piece$(a$, "%") if len(a$())=1 then =str$(a$):exit k=each(a$(),2) \\ convert to one byte per character using str$(string) acc$=str$(a$(0)) While k { \\ chr$() convert to UTF16LE \\ str$() convert to ANSI using locale (can be 1033 we can set it before as Locale 1033) \\ so chr$(0x93) give 0x201C \\ str$(chr$(0x93)) return one byte 93 in ANSI as string of one byte length \\ numbers are for UTF-8 so we have to preserve them acc$+=str$(Chr$(Eval("0x"+left$(a$(k^),2)))+Mid$(a$(k^),3)) } =acc$ } \\ decode from utf8 final$=DecodeUrl$("google.com/search?q=%60Abdu%27l-Bah%C3%A1") Print string$(final$ as utf8dec)="google.com/search?q=`Abdu'l-Bahá" final$=DecodeUrl$("http%3A%2F%2Ffoo%20bar%2F") Print string$(final$ as utf8dec)="http://foo bar/"
} CheckIt </lang>
Maple
<lang Maple>StringTools:-Decode("http%3A%2F%2Ffoo%20bar%2F", encoding=percent);</lang>
- Output:
"http://foo bar/"
Mathematica
<lang mathematica>URLDecoding[url_] :=
StringReplace[url, "%" ~~ x_ ~~ y_ :> FromDigits[x ~~ y, 16]] //. StringExpression[x___, Longest[n__Integer], y___] :> StringExpression[x, FromCharacterCode[{n}, "UTF8"], y]</lang>
Example use:
<lang mathematica>URLDecoding["http%3A%2F%2Ffoo%20bar%2F"]</lang>
- Output:
http://foo bar/
MATLAB / Octave
<lang MATLAB>function u = urldecoding(s)
u = ; k = 1; while k<=length(s) if s(k) == '%' && k+2 <= length(s) u = sprintf('%s%c', u, char(hex2dec(s((k+1):(k+2))))); k = k + 3; else u = sprintf('%s%c', u, s(k)); k = k + 1; end end
end</lang> Usage:
octave:3> urldecoding('http%3A%2F%2Ffoo%20bar%2F') ans = http://foo bar/
NetRexx
<lang NetRexx>/* NetRexx */ options replace format comments java crossref savelog symbols nobinary
url = [ -
'http%3A%2F%2Ffoo%20bar%2F', - 'mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E', - '%6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E' - ]
loop u_ = 0 to url.length - 1
say url[u_] say DecodeURL(url[u_]) say end u_
return
method DecodeURL(arg) public static
Parse arg encoded decoded = PCT = '%'
loop label e_ while encoded.length() > 0 parse encoded head (PCT) +1 code +2 tail decoded = decoded || head select when code.strip('T').length() = 2 & code.datatype('X') then do code = code.x2c() decoded = decoded || code end when code.strip('T').length() \= 0 then do decoded = decoded || PCT tail = code || tail end otherwise do nop end end encoded = tail end e_
return decoded
</lang>
- Output:
http%3A%2F%2Ffoo%20bar%2F http://foo bar/ mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E mailto:"Ivan Aim" <ivan.aim@email.com> %6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E mailto:"Irma User" <irma.user@mail.com>
NewLISP
<lang NewLISP>;; universal decoder, works for ASCII and UTF-8
(define (url-decode url (opt nil))
(if opt (replace "+" url " ")) (replace "%([0-9a-f][0-9a-f])" url (pack "b" (int $1 0 16)) 1))
(url-decode "http%3A%2F%2Ffoo%20bar%2F")</lang>
Nim
<lang nim>import cgi
echo decodeUrl("http%3A%2F%2Ffoo%20bar%2F")</lang>
Oberon-2
<lang oberon2> MODULE URLDecoding; IMPORT
URI := URI:String, Out := NPCT:Console;
BEGIN
Out.String(URI.Unescape("http%3A%2F%2Ffoo%20bar%2F"));Out.Ln; Out.String(URI.Unescape("google.com/search?q=%60Abdu%27l-Bah%C3%A1"));Out.Ln;
END URLDecoding. </lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
Objeck
<lang objeck> class UrlDecode {
function : Main(args : String[]) ~ Nil { Net.UrlUtility->Decode("http%3A%2F%2Ffoo%20bar%2F")->PrintLine(); }
} </lang>
Objective-C
<lang objc>NSString *encoded = @"http%3A%2F%2Ffoo%20bar%2F"; NSString *normal = [encoded stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding]; NSLog(@"%@", normal);</lang>
<lang objc>NSString *encoded = @"http%3A%2F%2Ffoo%20bar%2F"; NSString *normal = [encoded stringByRemovingPercentEncoding]; NSLog(@"%@", normal);</lang>
OCaml
Using the library ocamlnet from the interactive loop:
<lang ocaml>$ ocaml
- #use "topfind";;
- #require "netstring";;
- Netencoding.Url.decode "http%3A%2F%2Ffoo%20bar%2F" ;;
- : string = "http://foo bar/"</lang>
ooRexx
While the implementation shown for Rexx will also work with ooRexx, this version uses ooRexx syntax to invoke the built-in functions. <lang ooRexx>/* Rexx */
X = 0 url. = X = X + 1; url.0 = X; url.X = 'http%3A%2F%2Ffoo%20bar%2F' X = X + 1; url.0 = X; url.X = 'mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E' X = X + 1; url.0 = X; url.X = '%6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E'
Do u_ = 1 to url.0 Say url.u_ Say DecodeURL(url.u_) Say End u_
Exit
DecodeURL: Procedure
Parse Arg encoded decoded = PCT = '%'
Do label e_ while encoded~length() > 0 Parse Var encoded head (PCT) +1 code +2 tail decoded = decoded || head Select when code~strip('T')~length() = 2 & code~datatype('X') then Do code = code~x2c() decoded = decoded || code End when code~strip('T')~length() \= 0 then Do decoded = decoded || PCT tail = code || tail End otherwise Nop End encoded = tail End e_
Return decoded</lang>
- Output:
http%3A%2F%2Ffoo%20bar%2F http://foo bar/ mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E mailto:"Ivan Aim" <ivan.aim@email.com> %6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E mailto:"Irma User" <irma.user@mail.com>
Perl
<lang Perl>sub urldecode {
my $s = shift; $s =~ tr/\+/ /; $s =~ s/\%([A-Fa-f0-9]{2})/pack('C', hex($1))/eg; return $s;
}
print urldecode('http%3A%2F%2Ffoo+bar%2F')."\n"; </lang>
<lang Perl>#!/usr/bin/perl -w use strict ; use URI::Escape ;
my $encoded = "http%3A%2F%2Ffoo%20bar%2F" ; my $unencoded = uri_unescape( $encoded ) ; print "The unencoded string is $unencoded !\n" ;</lang>
Phix
<lang Phix>-- -- demo\rosetta\decode_url.exw -- =========================== -- function decode_url(string s) integer skip = 0 string res = ""
for i=1 to length(s) do if skip then skip -= 1 else integer ch = s[i] if ch='%' then sequence scanres = {} if i+2<=length(s) then scanres = scanf("#"&s[i+1..i+2],"%x") end if if length(scanres)!=1 then return "decode error" end if skip = 2 ch = scanres[1][1] elsif ch='+' then ch = ' ' end if res &= ch end if end for return res
end function
printf(1,"%s\n",{decode_url("http%3A%2F%2Ffoo%20bar%2F")}) printf(1,"%s\n",{decode_url("google.com/search?q=%60Abdu%27l-Bah%C3%A1")})</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
PHP
<lang php><?php $encoded = "http%3A%2F%2Ffoo%20bar%2F"; $unencoded = rawurldecode($encoded); echo "The unencoded string is $unencoded !\n"; ?></lang>
PicoLisp
: (ht:Pack (chop "http%3A%2F%2Ffoo%20bar%2F") T) -> "http://foo bar/"
Pike
<lang Pike> void main() {
array encoded_urls = ({ "http%3A%2F%2Ffoo%20bar%2F", "google.com/search?q=%60Abdu%27l-Bah%C3%A1" });
foreach(encoded_urls, string url) { string decoded = Protocols.HTTP.uri_decode( url ); write( string_to_utf8(decoded) +"\n" ); // Assume sink does UTF8 }
} </lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
PowerShell
<lang PowerShell> [System.Web.HttpUtility]::UrlDecode("http%3A%2F%2Ffoo%20bar%2F") </lang>
- Output:
http://foo bar/
PureBasic
<lang PureBasic>URL$ = URLDecoder("http%3A%2F%2Ffoo%20bar%2F")
Debug URL$ ; http://foo bar/</lang>
Python
<lang Python>
- Python 2.X
import urllib print urllib.unquote("http%3A%2F%2Ffoo%20bar%2F")
- Python 3.5+
from urllib.parse import unquote print(unquote('http%3A%2F%2Ffoo%20bar%2F')) </lang>
R
<lang R>URLdecode("http%3A%2F%2Ffoo%20bar%2F")</lang>
Racket
<lang racket>
- lang racket
(require net/uri-codec) (uri-decode "http%3A%2F%2Ffoo%20bar%2F") </lang>
Raku
(formerly Perl 6) <lang perl6>my $url = "http%3A%2F%2Ffoo%20bar%2F";
say $url.subst: :g,
/'%'(<:hexdigit>**2)/, -> ($ord ) { chr(:16(~$ord)) }
- Alternately, you can use an in-place substitution:
$url ~~ s:g[ '%' (<:hexdigit> ** 2) ] = chr :16(~$0); say $url;</lang>
Retro
This is provided by the casket library (used for web app development).
<lang Retro>create buffer 32000 allot
{{
create bit 5 allot : extract ( $c-$a ) drop @+ bit ! @+ bit 1+ ! bit ; : render ( $c-$n ) dup '+ = [ drop 32 ] ifTrue dup 13 = [ drop 32 ] ifTrue dup 10 = [ drop 32 ] ifTrue dup '% = [ extract hex toNumber decimal ] ifTrue ; : <decode> ( $-$ ) repeat @+ 0; render ^buffer'add again ;
---reveal---
: decode ( $- ) buffer ^buffer'set <decode> drop ;
}}
"http%3A%2F%2Ffoo%20bar%2F" decode buffer puts</lang>
REXX
version 1
Tested with the ooRexx and Regina interpreters. <lang REXX>/* Rexx */
Do
X = 0 url. = X = X + 1; url.0 = X; url.X = 'http%3A%2F%2Ffoo%20bar%2F' X = X + 1; url.0 = X; url.X = 'mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E' X = X + 1; url.0 = X; url.X = '%6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E'
Do u_ = 1 to url.0 Say url.u_ Say DecodeURL(url.u_) Say End u_
Return
End Exit
DecodeURL: Procedure Do
Parse Arg encoded decoded = PCT = '%'
Do while length(encoded) > 0 Parse Var encoded head (PCT) +1 code +2 tail decoded = decoded || head Select When length(strip(code, 'T')) = 2 & datatype(code, 'X') then Do code = x2c(code) decoded = decoded || code End When length(strip(code, 'T')) \= 0 then Do decoded = decoded || PCT tail = code || tail End Otherwise Do Nop End End encoded = tail End
Return decoded
End Exit </lang>
- Output:
http%3A%2F%2Ffoo%20bar%2F http://foo bar/ mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E mailto:"Ivan Aim" <ivan.aim@email.com> %6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E mailto:"Irma User" <irma.user@mail.com>
version 2
This REXX version is identical to version 1, but with superfluous and dead code removed. <lang REXX>/*REXX program converts a URL─encoded string ──► its original unencoded form. */ url.1='http%3A%2F%2Ffoo%20bar%2F' url.2='mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E' url.3='%6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E' URLs =3
do j=1 for URLs say url.j say decodeURL(url.j) say end /*j*/
exit /*──────────────────────────────────────────────────────────────────────────────────────*/ decodeURL: procedure; parse arg encoded; decoded=
do while encoded\== parse var encoded head '%' +1 code +2 tail decoded= decoded || head L= length( strip( code, 'T') ) select when L==2 & datatype(code, "X") then decoded= decoded || x2c(code) when L\==0 then do; decoded= decoded'%' tail= code || tail end otherwise nop end /*select*/ encoded= tail end /*while*/
return decoded</lang>
- output is identical to the 1st REXX version.
version 3
This REXX version is a shorter version of version 2. <lang REXX>/*REXX program converts & displays a URL─encoded string ──► its original unencoded form.*/ url. = url.1='http%3A%2F%2Ffoo%20bar%2F' url.2='mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E' url.3='%6D%61%69%6C%74%6F%3A%22%49%72%6D%61%20%55%73%65%72%22%20%3C%69%72%6D%61%2E%75%73%65%72%40%6D%61%69%6C%2E%63%6F%6D%3E'
do j=1 until url.j==; say /*process each URL; display blank line.*/ say url.j /*display the original URL. */ say URLdecode(url.j) /* " " decoded " */ end /*j*/
exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ URLdecode: procedure; parse arg yyy /*get encoded URL from argument list. */
yyy= translate(yyy, , '+') /*a special case for an encoded blank. */ URL= do until yyy== parse var yyy plain '%' +1 code +2 yyy URL= URL || plain if datatype(code, 'X') then URL= URL || x2c(code) else URL= URL'%'code end /*until*/ return URL</lang>
- output is identical to the 1st REXX version.
Ruby
Use any one of CGI.unescape
or URI.decode_www_form_component
. These methods also convert "+" to " ".
<lang ruby>require 'cgi' puts CGI.unescape("http%3A%2F%2Ffoo%20bar%2F")
- => "http://foo bar/"</lang>
<lang ruby>require 'uri' puts URI.decode_www_form_component("http%3A%2F%2Ffoo%20bar%2F")
- => "http://foo bar/"</lang>
URI.unescape
(alias URI.unencode
) still works. URI.unescape
is obsolete since Ruby 1.9.2 because of problems with its sibling URI.escape
.
Rust
<lang rust>const INPUT1: &str = "http%3A%2F%2Ffoo%20bar%2F"; const INPUT2: &str = "google.com/search?q=%60Abdu%27l-Bah%C3%A1";
fn append_frag(text: &mut String, frag: &mut String) {
if !frag.is_empty() { let encoded = frag.chars() .collect::<Vec<char>>() .chunks(2) .map(|ch| { u8::from_str_radix(&ch.iter().collect::<String>(), 16).unwrap() }).collect::<Vec<u8>>(); text.push_str(&std::str::from_utf8(&encoded).unwrap()); frag.clear(); }
}
fn decode(text: &str) -> String {
let mut output = String::new(); let mut encoded_ch = String::new(); let mut iter = text.chars(); while let Some(ch) = iter.next() { if ch == '%' { encoded_ch.push_str(&format!("{}{}", iter.next().unwrap(), iter.next().unwrap())); } else { append_frag(&mut output, &mut encoded_ch); output.push(ch); } } append_frag(&mut output, &mut encoded_ch); output
}
fn main() {
println!("{}", decode(INPUT1)); println!("{}", decode(INPUT2));
}</lang>
- Output:
http://foo bar/ google.com/search?q=`Abdu'l-Bahá
Scala
<lang scala>import java.net.{URLDecoder, URLEncoder}
import scala.compat.Platform.currentTime
object UrlCoded extends App {
val original = """http://foo bar/""" val encoded: String = URLEncoder.encode(original, "UTF-8")
assert(encoded == "http%3A%2F%2Ffoo+bar%2F", s"Original: $original not properly encoded: $encoded")
val percentEncoding = encoded.replace("+", "%20") assert(percentEncoding == "http%3A%2F%2Ffoo%20bar%2F", s"Original: $original not properly percent-encoded: $percentEncoding")
assert(URLDecoder.decode(encoded, "UTF-8") == URLDecoder.decode(percentEncoding, "UTF-8"))
println(s"Successfully completed without errors. [total ${currentTime - executionStart} ms]")
}</lang>
Seed7
The library encoding.s7i defines functions to handle URL respectively percent encoding. The function fromPercentEncoded decodes a percend-encoded string. The function fromUrlEncoded works like fromPercentEncoded and additionally decodes '+' with a space. Both functions return byte sequences. To decode Unicode characters it is necessary to convert them from UTF-8 with utf8ToStri afterwards. <lang seed7>$ include "seed7_05.s7i";
include "encoding.s7i";
const proc: main is func
begin writeln(fromPercentEncoded("http%3A%2F%2Ffoo%20bar%2F")); writeln(fromUrlEncoded("http%3A%2F%2Ffoo+bar%2F")); end func;</lang>
- Output:
http://foo bar/ http://foo bar/
Sidef
<lang ruby>func urldecode(str) {
str.gsub!('+', ' '); str.gsub!(/\%([A-Fa-f0-9]{2})/, {|a| 'C'.pack(a.hex)}); return str;
}
say urldecode('http%3A%2F%2Ffoo+bar%2F'); # => "http://foo bar/"</lang>
Swift
<lang swift>import Foundation
let encoded = "http%3A%2F%2Ffoo%20bar%2F" if let normal = encoded.stringByReplacingPercentEscapesUsingEncoding(NSUTF8StringEncoding) {
println(normal)
}</lang>
Tcl
This code is careful to ensure that any untoward metacharacters in the input string still do not cause any problems. <lang tcl>proc urlDecode {str} {
set specialMap {"[" "%5B" "]" "%5D"} set seqRE {%([0-9a-fA-F]{2})} set replacement {[format "%c" [scan "\1" "%2x"]]} set modStr [regsub -all $seqRE [string map $specialMap $str] $replacement] return [encoding convertfrom utf-8 [subst -nobackslash -novariable $modStr]]
}</lang> Demonstrating: <lang tcl>puts [urlDecode "http%3A%2F%2Ffoo%20bar%2F"]</lang>
- Output:
http://foo bar/
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT url_encoded="http%3A%2F%2Ffoo%20bar%2F" BUILD S_TABLE hex=":%><:><2<>2<%:" hex=STRINGS (url_encoded,hex), hex=SPLIT(hex) hex=DECODE (hex,hex) url_decoded=SUBSTITUTE(url_encoded,":%><2<>2<%:",0,0,hex) PRINT "encoded: ", url_encoded PRINT "decoded: ", url_decoded </lang>
- Output:
encoded: http%3A%2F%2Ffoo%20bar%2F decoded: http://foo bar/
UNIX Shell
<lang bash>urldecode() { local u="${1//+/ }"; printf '%b' "${u//%/\\x}"; }</lang>
Example:
<lang bash>urldecode http%3A%2F%2Ffoo%20bar%2F http://foo bar/
urldecode google.com/search?q=%60Abdu%27l-Bah%C3%A1 google.com/search?q=`Abdu'l-Bahároot@ </lang>
<lang bash>function urldecode {
typeset encoded=$1 decoded= rest= c= c1= c2= typeset rest2= bug='rest2=${rest}'
if [[ -z ${BASH_VERSION:-} ]]; then typeset -i16 hex=0; typeset -i8 oct=0
# bug /usr/bin/sh HP-UX 11.00 typeset _encoded='xyz%26xyz' rest="${_encoded#?}" c="${_encoded%%${rest}}" if (( ${#c} != 1 )); then typeset qm='????????????????????????????????????????????????????????????????????????' typeset bug='(( ${#rest} > 0 )) && typeset -L${#rest} rest2="${qm}" || rest2=${rest}' fi fi
rest="${encoded#?}" eval ${bug} c="${encoded%%${rest2}}" encoded="${rest}"
while [[ -n ${c} ]]; do if [[ ${c} = '%' ]]; then rest="${encoded#?}" eval ${bug} c1="${encoded%%${rest2}}" encoded="${rest}"
rest="${encoded#?}" eval ${bug} c2="${encoded%%${rest2}}" encoded="${rest}"
if [[ -z ${c1} || -z ${c2} ]]; then c="%${c1}${c2}" echo "WARNING: invalid % encoding: ${c}" >&2 elif [[ -n ${BASH_VERSION:-} ]]; then c="\\x${c1}${c2}" c=$(\echo -e "${c}") else hex="16#${c1}${c2}"; oct=hex c="\\0${oct#8\#}" c=$(print -- "${c}") fi elif [[ ${c} = '+' ]]; then c=' ' fi
decoded="${decoded}${c}"
rest="${encoded#?}" eval ${bug} c="${encoded%%${rest2}}" encoded="${rest}" done
if [[ -n ${BASH_VERSION:-} ]]; then \echo -E "${decoded}" else print -r -- "${decoded}" fi } </lang>
VBScript
<lang VBScript>Function RegExTest(str,patrn)
Dim regEx Set regEx = New RegExp regEx.IgnoreCase = True regEx.Pattern = patrn RegExTest = regEx.Test(str)
End Function
Function URLDecode(sStr)
Dim str,code,a0 str="" code=sStr code=Replace(code,"+"," ") While len(code)>0 If InStr(code,"%")>0 Then str = str & Mid(code,1,InStr(code,"%")-1) code = Mid(code,InStr(code,"%")) a0 = UCase(Mid(code,2,1)) If a0="U" And RegExTest(code,"^%u[0-9A-F]{4}") Then str = str & ChrW((Int("&H" & Mid(code,3,4)))) code = Mid(code,7) ElseIf a0="E" And RegExTest(code,"^(%[0-9A-F]{2}){3}") Then str = str & ChrW((Int("&H" & Mid(code,2,2)) And 15) * 4096 + (Int("&H" & Mid(code,5,2)) And 63) * 64 + (Int("&H" & Mid(code,8,2)) And 63)) code = Mid(code,10) ElseIf a0>="C" And a0<="D" And RegExTest(code,"^(%[0-9A-F]{2}){2}") Then str = str & ChrW((Int("&H" & Mid(code,2,2)) And 3) * 64 + (Int("&H" & Mid(code,5,2)) And 63)) code = Mid(code,7) ElseIf (a0<="B" Or a0="F") And RegExTest(code,"^%[0-9A-F]{2}") Then str = str & Chr(Int("&H" & Mid(code,2,2))) code = Mid(code,4) Else str = str & "%" code = Mid(code,2) End If Else str = str & code code = "" End If Wend URLDecode = str
End Function
url = "http%3A%2F%2Ffoo%20bar%C3%A8%2F" WScript.Echo "Encoded URL: " & url & vbCrLf &_ "Decoded URL: " & UrlDecode(url)</lang>
- Output:
Encoded URL: http%3A%2F%2Ffoo%20bar%C3%A8%2F Decoded URL: http://foo barè/
XPL0
<lang XPL0>code Text=12; string 0; \use zero-terminated strings
func Decode(S0); \Decode URL string and return its address char S0; char S1(80); \BEWARE: very temporary string space returned int C, N, I, J; [I:= 0; J:= 0; repeat C:= S0(I); I:= I+1; \get char
if C=^% then \convert hex to char [C:= S0(I); I:= I+1; if C>=^a then C:= C & ~$20; \convert to uppercase N:= C - (if C<=^9 then ^0 else ^A-10); C:= S0(I); I:= I+1; if C>=^a then C:= C & ~$20; C:= N*16 + C - (if C<=^9 then ^0 else ^A-10); ]; S1(J):= C; J:= J+1; \put char in output string
until C=0; return S1; ];
Text(0, Decode("http%3A%2F%2Ffoo%20bar%2f"))</lang>
- Output:
http://foo bar/
Yabasic
<lang Yabasic>sub decode_url$(s$)
local res$, ch$
while(s$ <> "") ch$ = left$(s$, 1) if ch$ = "%" then ch$ = chr$(dec(mid$(s$, 2, 2))) s$ = right$(s$, len(s$) - 3) else if ch$ = "+" ch$ = " " s$ = right$(s$, len(s$) - 1)
endif
res$ = res$ + ch$ wend return res$
end sub
print decode_url$("http%3A%2F%2Ffoo%20bar%2F") print decode_url$("google.com/search?q=%60Abdu%27l-Bah%C3%A1")</lang>
zkl
<lang zkl>"http%3A%2F%2Ffoo%20bar%2F".pump(String, // push each char through these fcns:
fcn(c){ if(c=="%") return(Void.Read,2); return(Void.Skip,c) },// %-->read 2 chars else pass through fcn(_,b,c){ (b+c).toInt(16).toChar() }) // "%" (ignored) "3"+"1"-->0x31-->"1"</lang>
- Output:
http://foo bar/
or use libCurl: <lang zkl>var Curl=Import.lib("zklCurl"); Curl.urlDecode("http%3A%2F%2Ffoo%20bar%2F");</lang>
- Output:
http://foo bar/
- Programming Tasks
- Solutions by Programming Task
- String manipulation
- ABAP
- Ada
- AWS
- ALGOL 68
- Apex
- AppleScript
- AppleScript Toolbox
- Arturo
- AutoHotkey
- AWK
- BaCon
- BBC BASIC
- Bracmat
- C
- C sharp
- C++
- Poco
- Caché ObjectScript
- Clojure
- CoffeeScript
- Common Lisp
- D
- Delphi
- Elixir
- Erlang
- F Sharp
- Factor
- Free Pascal
- Go
- Groovy
- Haskell
- Icon
- Unicon
- Icon Programming Library
- J
- Java
- JavaScript
- Jq
- Julia
- Kotlin
- Lambdatalk
- Lasso
- Liberty BASIC
- Lingo
- LiveCode
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- MATLAB
- Octave
- NetRexx
- NewLISP
- Nim
- Oberon-2
- Objeck
- Objective-C
- OCaml
- OoRexx
- Perl
- Phix
- PHP
- PicoLisp
- Pike
- PowerShell
- PureBasic
- Python
- R
- Racket
- Raku
- Retro
- REXX
- Ruby
- Rust
- Scala
- Seed7
- Sidef
- Swift
- Tcl
- TUSCRIPT
- UNIX Shell
- VBScript
- XPL0
- Yabasic
- Zkl