Rosetta Code

URL encoding: Difference between revisions

Page Discussion

URL encoding (view source)

Revision as of 21:39, 14 June 2024

60,456 bytes added ,  23 days ago
→‎{{header|langur}}
m (options added)
 
(187 intermediate revisions by more than 100 users not shown)
Line 1:
{{draft task}}
[[Category:String manipulation]]
The task is to provide a function or mechanism to convert a provided string into URL encoding representation.
[[Category: Encodings]]
 
;Task:
In URL encoding, special characters, control characters and extended characters are converted into a percent symbol followed by a two digit hexadecimal code, So a space character encodes into %20 within the string.
Provide a function or mechanism to convert a provided string into URL encoding representation.
 
In URL encoding, special characters, control characters and extended characters
The following characters require conversion:
are converted into a percent symbol followed by a two digit hexadecimal code,
So a space character encodes into %20 within the string.
 
For the purposes of this task, every character except 0-9, A-Z and a-z requires conversion, so the following characters all require conversion by default:
*ASCII control codes (Character ranges 00-1F hex (0-31 decimal) and 7F (127 decimal).
*ASCII symbols (Character ranges 32-47 decimal (20-2F hex))
*ASCII symbols (Character ranges 58-64 decimal (3A-40 hex))
*ASCII symbols (Character ranges 91-96 decimal (5B-60 hex))
*ASCII symbols (Character ranges 123-126 decimal (7B-7E hex))
*Extended characters with character codes of 128 decimal (80 hex) and above.
 
* ASCII control codes (Character ranges 00-1F hex (0-31 decimal) and 7F (127 decimal).
'''Example'''
* ASCII symbols (Character ranges 32-47 decimal (20-2F hex))
* ASCII symbols (Character ranges 58-64 decimal (3A-40 hex))
* ASCII symbols (Character ranges 91-96 decimal (5B-60 hex))
* ASCII symbols (Character ranges 123-126 decimal (7B-7E hex))
* Extended characters with character codes of 128 decimal (80 hex) and above.
 
<br>
;Example:
The string "<code><nowiki>http://foo bar/</nowiki></code>" would be encoded as "<code><nowiki>http%3A%2F%2Ffoo%20bar%2F</nowiki></code>".
 
'''Options'''
 
;Variations:
It is permissible for an exception string (containing a set of symbols that do not need to be converted) to be utilized. However, this is an optional feature and is not a requirement of this task.
* Lowercase escapes are legal, as in "<code><nowiki>http%3a%2f%2ffoo%20bar%2f</nowiki></code>".
* Special characters have different encodings for different standards:
** RFC 3986, ''Uniform Resource Identifier (URI): Generic Syntax'', section 2.3, says to preserve "-._~".
** HTML 5, section [http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#url-encoded-form-data 4.10.22.5 URL-encoded form data], says to preserve "-._*", and to encode space " " to "+".
** [https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI#description encodeURI] function in Javascript will preserve "-._~" (RFC 3986) and ";,/?:@&=+$!*'()#".
 
;Options:
'''See also'''
It is permissible to use an exception string (containing a set of symbols
that do not need to be converted).
However, this is an optional feature and is not a requirement of this task.
 
[[URL decoding]]
 
;Related tasks:
[[Category:String manipulation]]
* &nbsp; [[URL decoding]]
* &nbsp; [[URL parser]]
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">F url_encode(s)
V r = ‘’
V buf = ‘’
 
F flush_buf() // this function is needed because strings in 11l are UTF-16 encoded
I @buf != ‘’
V bytes = @buf.encode(‘utf-8’)
L(b) bytes
@r ‘’= ‘%’hex(b).zfill(2)
@buf = ‘’
 
L(c) s
I c C (‘0’..‘9’, ‘a’..‘z’, ‘A’..‘Z’, ‘_’, ‘.’, ‘-’, ‘~’)
flush_buf()
r ‘’= c
E
buf ‘’= c
 
flush_buf()
R r
 
print(url_encode(‘http://foo bar/’))
print(url_encode(‘https://ru.wikipedia.org/wiki/Транспайлер’))</syntaxhighlight>
 
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
https%3A%2F%2Fru.wikipedia.org%2Fwiki%2F%D0%A2%D1%80%D0%B0%D0%BD%D1%81%D0%BF%D0%B0%D0%B9%D0%BB%D0%B5%D1%80
</pre>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">BYTE FUNC MustEncode(CHAR c CHAR ARRAY ex)
BYTE i
 
IF c>='a AND c<='z OR c>='A AND c<='Z OR c>='0 AND c<='9 THEN
RETURN (0)
FI
IF ex(0)>0 THEN
FOR i=1 TO ex(0)
DO
IF ex(i)=c THEN
RETURN (0)
FI
OD
FI
RETURN (1)
 
PROC Append(CHAR ARRAY s CHAR c)
s(0)==+1
s(s(0))=c
RETURN
 
PROC Encode(CHAR ARRAY in,out,ex BYTE spaceToPlus)
CHAR ARRAY hex=['0 '1 '2 '3 '4 '5 '6 '7 '8 '9 'A 'B 'C 'D 'E 'F]
BYTE i
CHAR c
 
out(0)=0
FOR i=1 TO in(0)
DO
c=in(i)
IF spaceToPlus=1 AND c=32 THEN
Append(out,'+)
ELSEIF MustEncode(c,ex) THEN
Append(out,'%)
Append(out,hex(c RSH 4))
Append(out,hex(c&$0F))
ELSE
Append(out,c)
FI
OD
RETURN
 
PROC EncodeRaw(CHAR ARRAY in,out)
Encode(in,out,"",0)
RETURN
 
PROC EncodeRFC3986(CHAR ARRAY in,out)
Encode(in,out,"-._~",0)
RETURN
 
PROC EncodeHTML5(CHAR ARRAY in,out)
Encode(in,out,"-._*",1)
RETURN
 
PROC PrintInv(CHAR ARRAY a)
BYTE i
 
IF a(0)>0 THEN
FOR i=1 TO a(0)
DO
Put(a(i)%$80)
OD
FI
RETURN
 
PROC Test(CHAR ARRAY in)
CHAR ARRAY out(256)
 
PrintInv("input ")
PrintF(" %S%E",in)
 
EncodeRaw(in,out)
PrintInv("encoded ")
PrintF(" %S%E",out)
 
EncodeRFC3986(in,out)
PrintInv("RFC 3986")
PrintF(" %S%E",out)
 
EncodeHTML5(in,out)
PrintInv("HTML 5 ")
PrintF(" %S%E%E",out)
RETURN
 
PROC Main()
Test("http://foo bar/")
Test("http://www.rosettacode.org/wiki/URL_encoding")
Test("http://foo bar/*_-.html")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/URL_encoding.png Screenshot from Atari 8-bit computer]
<pre>
input http://foo bar/
encoded http%3A%2F%2Ffoo%20bar%2F
RFC 3986 http%3A%2F%2Ffoo%20bar%2F
HTML 5 http%3A%2F%2Ffoo+bar%2F
 
input http://www.rosettacode.org/wiki/URL_encoding
encoded http%3A%2F%2Fwww%2Erosettacode%2Eorg%2Fwiki%2FURL%5Fencoding
RFC 3986 http%3A%2F%2Fwww.rosettacode.org%2Fwiki%2FURL_encoding
HTML 5 http%3A%2F%2Fwww.rosettacode.org%2Fwiki%2FURL_encoding
 
input http://foo bar/*_-.html
encoded http%3A%2F%2Ffoo%20bar%2F%2A%5F%2D%2Ehtml
RFC 3986 http%3A%2F%2Ffoo%20bar%2F%2A_-.html
HTML 5 http%3A%2F%2Ffoo+bar%2F*_-.html
</pre>
 
=={{header|Ada}}==
{{libheader|AWS}}
<syntaxhighlight lang="ada">with AWS.URL;
with Ada.Text_IO; use Ada.Text_IO;
procedure Encode is
Normal : constant String := "http://foo bar/";
begin
Put_Line (AWS.URL.Encode (Normal));
end Encode;</syntaxhighlight>
{{out}}
<pre>http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN
# encodes the specified url - 0-9, A-Z and a-z are unchanged, #
# everything else is converted to %xx where xx are hex-digits #
PROC encode url = ( STRING url )STRING:
IF url = "" THEN "" # empty string #
ELSE
# non-empty string #
# ensure result will be big enough for a string of all encodable #
# characters #
STRING hex digits = "0123456789ABCDEF";
[ 1 : ( ( UPB url - LWB url ) + 1 ) * 3 ]CHAR result;
INT r pos := 0;
FOR u pos FROM LWB url TO UPB url DO
CHAR c = url[ u pos ];
IF ( c >= "0" AND c <= "9" )
OR ( c >= "A" AND c <= "Z" )
OR ( c >= "a" AND c <= "z" )
THEN
# no need to encode this character #
result[ r pos +:= 1 ] := c
ELSE
# must encode #
INT c code = ABS c;
result[ r pos +:= 1 ] := "%";
result[ r pos +:= 1 ] := hex digits[ ( c code OVER 16 ) + 1 ];
result[ r pos +:= 1 ] := hex digits[ ( c code MOD 16 ) + 1 ]
FI
OD;
result[ 1 : r pos ]
FI; # encode url #
# task test case #
print( ( encode url( "http://foo bar/" ), newline ) )
END
</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Apex}}==
<syntaxhighlight lang="apex">EncodingUtil.urlEncode('http://foo bar/', 'UTF-8')</syntaxhighlight>
<pre>http%3A%2F%2Ffoo+bar%2F</pre>
 
=={{header|AppleScript}}==
{{libheader|AppleScript Toolbox}}
<syntaxhighlight lang="applescript">AST URL encode "http://foo bar/"</syntaxhighlight>
{{out}}
<pre>"http%3A%2F%2Ffoo%20bar%2F"</pre>
 
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="gwbasic"> 100 URL$ = "http://foo bar/"
110 GOSUB 140"URL ENCODE URL$ RETURNS R$
120 PRINT R$;
130 END
140 LET R$ = ""
150 LET L = LEN (URL$)
160 IF NOT L THEN RETURN
170 LET H$ = "0123456789ABCDEF"
180 FOR I = 1 TO L
190 LET C$ = MID$ (URL$,I,1)
200 LET C = ASC (C$)
210 IF C < ASC ("0") OR C > ASC ("Z") + 32 OR C > ASC ("9") AND C < ASC ("A") OR C > ASC ("Z") AND C < ASC ("A") + 32 THEN H = INT (C / 16):C$ = "%" + MID$ (H$,H + 1,1) + MID$ (H$,C - H * 16 + 1,1)
220 LET R$ = R$ + C$
230 NEXT I
240 RETURN</syntaxhighlight>
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">encoded: encode.url.slashes "http://foo bar/"
print encoded</syntaxhighlight>
 
{{out}}
 
<pre>http%3A%2F%2Ffoo+bar%2F</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">MsgBox, % UriEncode("http://foo bar/")
 
; Modified from http://goo.gl/0a0iJq
UriEncode(Uri, Reserved:="!#$&'()*+,/:;=?@[]") {
Unreserved := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~"
VarSetCapacity(Var, StrPut(Uri, "UTF-8"), 0)
StrPut(Uri, &Var, "UTF-8")
While (Code := NumGet(Var, A_Index - 1, "UChar")) {
If InStr(Unreserved . Reserved, Chr(Code)) {
Encoded .= Chr(Code)
}
Else {
Encoded .= Format("%{:02X}", Code)
}
}
Return Encoded
}</syntaxhighlight>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">BEGIN {
for (i = 0; i <= 255; i++)
ord[sprintf("%c", i)] = i
}
 
# Encode string with application/x-www-form-urlencoded escapes.
function escape(str, c, len, res) {
len = length(str)
res = ""
for (i = 1; i <= len; i++) {
c = substr(str, i, 1);
if (c ~ /[0-9A-Za-z]/)
#if (c ~ /[-._*0-9A-Za-z]/)
res = res c
#else if (c == " ")
# res = res "+"
else
res = res "%" sprintf("%02X", ord[c])
}
return res
}
 
# Escape every line of input.
{ print escape($0) }</syntaxhighlight>
 
The array <code>ord[]</code> uses idea from [[Character codes#AWK]].
 
To follow the rules for HTML 5, uncomment the two lines that convert " " to "+", and use the regular expression that preserves "-._*".
 
=={{header|Bash}}==
<syntaxhighlight lang="bash">urlencode() {
local LC_ALL=C # support unicode: loop bytes, not characters
local c i n=${#1}
for (( i=0; i<n; i++ )); do
c="${1:i:1}"
case "$c" in
#' ') printf '+' ;; # HTML5 variant
[[:alnum:].~_-]) printf '%s' "$c" ;;
*) printf '%%%02x' "'$c" ;;
esac
done
}
 
urlencode "http://foo bar/"</syntaxhighlight>
{{out}}
<pre>
http%3a%2f%2ffoo%20bar%2f
</pre>
 
To produce upper-case hex codes, replace <code>%02x</code> with <code>%02X</code>
 
See also: [http://mywiki.wooledge.org/BashFAQ/071 BashFAQ/071]
 
=={{header|BBC BASIC}}==
<syntaxhighlight lang="bbcbasic"> PRINT FNurlencode("http://foo bar/")
END
DEF FNurlencode(url$)
LOCAL c%, i%
WHILE i% < LEN(url$)
i% += 1
c% = ASCMID$(url$, i%)
IF c%<&30 OR c%>&7A OR c%>&39 AND c%<&41 OR c%>&5A AND c%<&61 THEN
url$ = LEFT$(url$,i%-1) + "%" + RIGHT$("0"+STR$~c%,2) + MID$(url$,i%+1)
ENDIF
ENDWHILE
= url$</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Bracmat}}==
<syntaxhighlight lang="bracmat">( ( encode
= encoded exceptions octet string
. !arg:(?exceptions.?string)
& :?encoded
& @( !string
: ?
( %@?octet ?
& !encoded
( !octet
: ( ~<0:~>9
| ~<A:~>Z
| ~<a:~>z
)
| @(!exceptions:? !octet ?)
& !octet
| "%" d2x$(asc$!octet)
)
: ?encoded
& ~
)
)
| str$!encoded
)
& out$"without exceptions:
"
& out$(encode$(."http://foo bar/"))
& out$(encode$(."mailto:Ivan"))
& out$(encode$(."Aim <ivan.aim@email.com>"))
& out$(encode$(."mailto:Irma"))
& out$(encode$(."User <irma.user@mail.com>"))
& out$(encode$(."http://foo.bar.com/~user-name/_subdir/*~.html"))
& out$"
with RFC 3986 rules:
"
& out$(encode$("-._~"."http://foo bar/"))
& out$(encode$("-._~"."mailto:Ivan"))
& out$(encode$("-._~"."Aim <ivan.aim@email.com>"))
& out$(encode$("-._~"."mailto:Irma"))
& out$(encode$("-._~"."User <irma.user@mail.com>"))
& out$(encode$("-._~"."http://foo.bar.com/~user-name/_subdir/*~.html"))
);
</syntaxhighlight>
{{out}}
<pre>without exceptions:
 
http%3A%2F%2Ffoo%20bar%2F
mailto%3AIvan
Aim%20%3Civan%2Eaim%40email%2Ecom%3E
mailto%3AIrma
User%20%3Cirma%2Euser%40mail%2Ecom%3E
http%3A%2F%2Ffoo%2Ebar%2Ecom%2F%7Euser%2Dname%2F%5Fsubdir%2F%2A%7E%2Ehtml
 
with RFC 3986 rules:
 
http%3A%2F%2Ffoo%20bar%2F
mailto%3AIvan
Aim%20%3Civan.aim%40email.com%3E
mailto%3AIrma
User%20%3Cirma.user%40mail.com%3E
http%3A%2F%2Ffoo.bar.com%2F~user-name%2F_subdir%2F%2A~.html</pre>
 
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#include <ctype.h>
char rfc3986[256] = {0};
char html5[256] = {0};
 
/* caller responsible for memory */
void encode(const char *s, char *enc, char *tb)
{
for (; *s; s++) {
if (tb[*s]) sprintf(enc, "%c", tb[*s]);
else sprintf(enc, "%%%02X", *s);
while (*++enc);
}
}
int main()
{
const char url[] = "http://foo bar/";
char enc[(strlen(url) * 3) + 1];
int i;
for (i = 0; i < 256; i++) {
rfc3986[i] = isalnum(i)||i == '~'||i == '-'||i == '.'||i == '_'
? i : 0;
html5[i] = isalnum(i)||i == '*'||i == '-'||i == '.'||i == '_'
? i : (i == ' ') ? '+' : 0;
}
encode(url, enc, rfc3986);
puts(enc);
return 0;
}</syntaxhighlight>
 
=={{header|C sharp}}==
 
<syntaxhighlight lang="c sharp">using System;
 
namespace URLEncode
{
internal class Program
{
private static void Main(string[] args)
{
Console.WriteLine(Encode("http://foo bar/"));
}
 
private static string Encode(string uri)
{
return Uri.EscapeDataString(uri);
}
}
}</syntaxhighlight>
 
{{out}}
<pre>http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|C++}}==
using Qt 4.6 as a library
<syntaxhighlight lang="cpp">#include <QByteArray>
#include <iostream>
 
int main( ) {
QByteArray text ( "http://foo bar/" ) ;
QByteArray encoded( text.toPercentEncoding( ) ) ;
std::cout << encoded.data( ) << '\n' ;
return 0 ;
}</syntaxhighlight>
{{out}}
<PRE>http%3A%2F%2Ffoo%20bar%2F</PRE>
 
=={{header|Clojure}}==
Using Java's URLEncoder:
<syntaxhighlight lang="clojure">(import 'java.net.URLEncoder)
(URLEncoder/encode "http://foo bar/" "UTF-8")</syntaxhighlight>
 
{{out}}<pre>"http%3A%2F%2Ffoo+bar%2F"</pre>
 
=={{header|ColdFusion}}==
 
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">(defun needs-encoding-p (char)
(not (digit-char-p char 36)))
 
(defun encode-char (char)
(format nil "%~2,'0X" (char-code char)))
 
(defun url-encode (url)
(apply #'concatenate 'string
(map 'list (lambda (char)
(if (needs-encoding-p char)
(encode-char char)
(string char)))
url)))
 
(url-encode "http://foo bar/")</syntaxhighlight>
{{out}}
<pre>"http%3A%2F%2Ffoo%20bar%2F"</pre>
 
=={{header|Crystal}}==
The standard library <code>URI</code> class provides methods for both the RFC 3986 and HTML 5 standards. The RFC 3986 method defaults to replacing space characters with <code>%20</code> but will replace them with <code>+</code> instead if the optional parameter <code>space_to_plus</code> is true. The HTML 5 method has the opposite default behavior.
<syntaxhighlight lang="crystal">require "uri"
 
puts URI.encode("http://foo bar/")
puts URI.encode("http://foo bar/", space_to_plus: true)
puts URI.encode_www_form("http://foo bar/")
puts URI.encode_www_form("http://foo bar/", space_to_plus: false)</syntaxhighlight>
{{out}}
<pre>http://foo%20bar/
http://foo+bar/
http%3A%2F%2Ffoo+bar%2F
http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|D}}==
<syntaxhighlight lang="d">import std.stdio, std.uri;
 
void main() {
writeln(encodeComponent("http://foo bar/"));
}</syntaxhighlight>
<pre>http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
function EncodeURL(URL: string): string;
var I: integer;
begin
Result:='';
for I:=1 to Length(URL) do
if URL[I] in ['0'..'9', 'A'..'Z', 'a'..'z'] then Result:=Result+URL[I]
else Result:=Result+'%'+IntToHex(byte(URL[I]),2);
end;
 
procedure EncodeAndShowURL(Memo: TMemo; URL: string);
var ES: string;
begin
Memo.Lines.Add('Unencoded URL: '+URL);
ES:=EncodeURL(URL);
Memo.Lines.Add('Encoded URL: '+ES);
Memo.Lines.Add('');
end;
 
procedure ShowEncodedURLs(Memo: TMemo);
begin
EncodeAndShowURL(Memo,'http://foo bar/');
EncodeAndShowURL(Memo,'https://rosettacode.org/wiki/URL_encoding');
EncodeAndShowURL(Memo,'https://en.wikipedia.org/wiki/Pikes_Peak_granite');
end;
 
 
 
</syntaxhighlight>
{{out}}
<pre>
Unencoded URL: http://foo bar/
Encoded URL: http%3A%2F%2Ffoo%20bar%2F
 
Unencoded URL: https://rosettacode.org/wiki/URL_encoding
Encoded URL: https%3A%2F%2Frosettacode%2Eorg%2Fwiki%2FURL%5Fencoding
 
Unencoded URL: https://en.wikipedia.org/wiki/Pikes_Peak_granite
Encoded URL: https%3A%2F%2Fen%2Ewikipedia%2Eorg%2Fwiki%2FPikes%5FPeak%5Fgranite
 
Elapsed Time: 11.734 ms.
</pre>
 
 
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">iex(1)> URI.encode("http://foo bar/", &URI.char_unreserved?/1)
"http%3A%2F%2Ffoo%20bar%2F"</syntaxhighlight>
 
=={{header|Erlang}}==
Built in, <code>http_uri:encode/1</code> accepts lists and binary:
 
<pre>
1> http_uri:encode("http://foo bar/").
"http%3A%2F%2Ffoo%20bar%2F"
</pre>
 
=== Unicode ===
If you are URL encoding unicode data though <code>http_uri:encode/1</code> will produce incorrect results:
<pre>
1> http_uri:encode("étanchéité d une terrasse").
"étanchéité%20d%20une%20terrasse"
</pre>
 
You should use the built-in (non-documented) <code>edoc_lib:escape_uri/1</code> instead:
<pre>
1> edoc_lib:escape_uri("étanchéité d une terrasse").
"%c3%a9tanch%c3%a9it%c3%a9%20d%20une%20terrasse"
</pre>
 
And for binary you will need to take care and use <code>unicode:characters_to_{list,binary}/1</code>:
<pre>
1> unicode:characters_to_binary(edoc_lib:escape_uri(unicode:characters_to_list(<<"étanchéité d une terrasse"/utf8>>))).
<<"%c3%a9tanch%c3%a9it%c3%a9%20d%20une%20terrasse">>
</pre>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">open System
 
[<EntryPoint>]
let main args =
printfn "%s" (Uri.EscapeDataString(args.[0]))
0</syntaxhighlight>
{{out}}
<pre>>URLencoding.exe "http://foo bar/"
http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|Factor}}==
Factor's built-in URL encoder doesn't encode <code>:</code> or <code>/</code>. However, we can write our own predicate quotation that tells <code>(url-encode)</code> what characters to exclude.
<syntaxhighlight lang="factor">USING: combinators.short-circuit unicode urls.encoding.private ;
 
: my-url-encode ( str -- encoded )
[ { [ alpha? ] [ "-._~" member? ] } 1|| ] (url-encode) ;
 
"http://foo bar/" my-url-encode print</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Free Pascal}}==
 
<syntaxhighlight lang="pascal">function urlEncode(data: string): AnsiString;
var
ch: AnsiChar;
begin
Result := '';
for ch in data do begin
if ((Ord(ch) < 65) or (Ord(ch) > 90)) and ((Ord(ch) < 97) or (Ord(ch) > 122)) then begin
Result := Result + '%' + IntToHex(Ord(ch), 2);
end else
Result := Result + ch;
end;
end;</syntaxhighlight>
 
 
=={{header|FreeBASIC}}==
{{trans|Liberty BASIC}}
<syntaxhighlight lang="freebasic">
Dim Shared As String lookUp(256)
For cadena As Integer = 0 To 256
lookUp(cadena) = "%" + Hex(cadena)
Next cadena
 
Function string2url(cadena As String) As String
Dim As String cadTemp, cadDevu
For j As Integer = 1 To Len(cadena)
cadTemp = Mid(cadena, j, 1)
If Instr( "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", cadTemp) Then
cadDevu &= cadTemp
Else
cadDevu &= lookUp(Asc(cadTemp))
End If
Next j
Return cadDevu
End Function
 
Dim As String URL = "http://foo bar/"
 
Print "Supplied URL '"; URL; "'"
Print "URL encoding '"; string2url(URL); "'"
Sleep
</syntaxhighlight>
{{out}}
<pre>Supplied URL 'http://foo bar/'
URL encoding 'http%3A%2F%2Ffoo%20bar%2F'</pre>
 
=={{header|Frink}}==
Frink has a built-in <code>URLEncode[<I>string</I>, <I>encoding="UTF-8"</I>]</code> function that correctly encodes strings (including high Unicode characters) for inclusion in a URL:
<syntaxhighlight lang="frink">println[URLEncode["http://foo bar/"]]</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo+bar%2F
</pre>
 
 
=={{header|FutureBasic}}==
<pre>
In addition to the generic alphanumeric character set used in the demo code below, FB offers several special character sets for URL encoding:
 
fn CharacterSetURLFragmentAllowedSet
fn CharacterSetURLHostAllowedSet
fn CharacterSetURLPasswordAllowedSet
fn CharacterSetURLPathAllowedSet
fn CharacterSetURLQueryAllowedSet
fn CharacterSetURLUserAllowedSet
 
Users can also create custom character strings with:
 
fn CharacterSetWithCharactersInString( CFStringRef string ) = CFCharacterSetRef
 
</pre>
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
 
local fn PercentEncodeURLString( urlStr as CFStringRef ) as CFStringRef
CFStringRef encodedStr = fn StringByAddingPercentEncodingWithAllowedCharacters( urlStr, fn CharacterSetAlphanumericSet )
end fn = encodedStr
 
NSLog( @"%@", fn PercentEncodeURLString( @"http://foo bar/" ) )
NSLog( @"%@", fn PercentEncodeURLString( @"http://www.rosettacode.org/wiki/URL_encoding" ) )
 
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
http%3A%2F%2Fwww%2Erosettacode%2Eorg%2Fwiki%2FURL%5Fencoding
</pre>
 
 
=={{header|Go}}==
<syntaxhighlight lang="go">package main
 
import (
"fmt"
"net/url"
)
 
func main() {
fmt.Println(url.QueryEscape("http://foo bar/"))
}</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo+bar%2F
</pre>
 
 
=={{header|Groovy}}==
<syntaxhighlight lang="groovy">
def normal = "http://foo bar/"
def encoded = URLEncoder.encode(normal, "utf-8")
println encoded
</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo+bar%2F
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import qualified Data.Char as Char
import Text.Printf
 
encode :: Char -> String
encode c
| c == ' ' = "+"
| Char.isAlphaNum c || c `elem` "-._~" = [c]
| otherwise = printf "%%%02X" c
 
urlEncode :: String -> String
urlEncode = concatMap encode
 
main :: IO ()
main = putStrLn $ urlEncode "http://foo bar/"</syntaxhighlight>
{{out}}
<pre>http%3A%2F%2Ffoo+bar%2F</pre>
 
=={{header|Icon}} and {{header|Unicon}}==
<langsyntaxhighlight Iconlang="icon">link hexcvt
 
procedure main()
Line 46 ⟶ 808:
return c
end
</syntaxhighlight>
</lang>
 
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/src/procs/hexcvt.icn hexcvt provides hexstring]
 
{{out}}
Output:<pre>text = "http://foo bar/"
<pre>text = "http://foo bar/"
encoded = "http%3A%2F%2Ffoo%20bar%2F"</pre>
 
Line 60 ⟶ 823:
Here's an implementation that does that:
 
<langsyntaxhighlight lang="j">require'strings convert'
urlencode=: rplc&((#~2|_1 47 57 64 90 96 122 I.i.@#)a.;"_1'%',.hfd i.#a.)</langsyntaxhighlight>
 
Example use:
 
<langsyntaxhighlight lang="j"> urlencode 'http://foo bar/'
http%3A%2F%2Ffoo%20bar%2F</langsyntaxhighlight>
 
=={{header|Java}}==
Java includes the ''URLEncoder'' and ''URLDecoder'' classes for this specific task.
 
<syntaxhighlight lang="java">
The built-in URLEncoder in Java converts the space " " into a plus-sign "+" instead of "%20":
<lang java>import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
</syntaxhighlight>
<syntaxhighlight lang="java">
URLEncoder.encode("http://foo bar/", StandardCharsets.UTF_8)
</syntaxhighlight>
Alternately, you could implement this with a basic for-loop.
<syntaxhighlight lang="java">
String encode(String string) {
StringBuilder encoded = new StringBuilder();
for (char character : string.toCharArray()) {
switch (character) {
/* rfc3986 and html5 */
case '-', '.', '_', '~', '*' -> encoded.append(character);
case ' ' -> encoded.append('+');
default -> {
if (alphanumeric(character))
encoded.append(character);
else {
encoded.append("%");
encoded.append("%02x".formatted((int) character));
}
}
}
}
return encoded.toString();
}
 
boolean alphanumeric(char character) {
public class Main
return (character >= 'A' && character <= 'Z')
|| (character >= 'a' && character <= 'z')
|| (character >= '0' && character <= '9');
}
</syntaxhighlight>
<pre>
http%3a%2f%2ffoo+bar%2f
</pre>
 
=={{header|JavaScript}}==
Confusingly, there are 3 different URI encoding functions in JavaScript: <code>escape()</code>, <code>encodeURI()</code>, and <code>encodeURIComponent()</code>. Each of them encodes a different set of characters. See [http://www.javascripter.net/faq/escape.htm this article] and [http://xkr.us/articles/javascript/encode-compare/ this article] for more information and comparisons.
<syntaxhighlight lang="javascript">var normal = 'http://foo/bar/';
var encoded = encodeURIComponent(normal);</syntaxhighlight>
 
=={{header|jq}}==
{{works with| jq | 1.4}}
 
jq has a built-in function, @uri, for "percent-encoding". It preserves the characters that RFC 3968 mandates
be preserved, but also preserves the following five characters: !'()*
 
To address the task requirement, therefore, we can first use @uri and then convert the exceptional characters.
(For versions of jq with regex support, this could be done using gsub, but here we perform
the translation directly.)
 
Note that @uri also converts multibyte characters to multi-triplets, e.g.
<syntaxhighlight lang="jq">"á" | @uri</syntaxhighlight> produces: "%C3%A1"
<syntaxhighlight lang="jq">def url_encode:
# The helper function checks whether the input corresponds to one of the characters: !'()*
def recode: . as $c | [33,39,40,41,42] | index($c);
def hex: if . < 10 then 48 + . else 55 + . end;
@uri
| explode
# 37 ==> "%", 50 ==> "2"
| map( if recode then (37, 50, ((. - 32) | hex)) else . end )
| implode;</syntaxhighlight>
'''Examples:'''
 
<syntaxhighlight lang="jq">"http://foo bar/" | @uri</syntaxhighlight>
produces: "http%3A%2F%2Ffoo%20bar%2F"
 
<syntaxhighlight lang="jq">"http://foo bar/" | @uri == url_encode</syntaxhighlight> produces: true
 
To contrast the difference between "@uri" and "url_encode", we compare the characters that are unaltered:
 
<syntaxhighlight lang="jq">[range(0;1024) | [.] | implode | if @uri == . then . else empty end] | join(null)</syntaxhighlight>
produces: "!'()*-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"
 
<syntaxhighlight lang="jq">[range(0;1024) | [.] | implode | if url_encode == . then . else empty end] | join(null)</syntaxhighlight>
produces: "-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">
//version 1.0.1
import HTTP.URIs: escapeuri
 
dcd = "http://foo bar/"
enc = escapeuri(dcd)
 
println(dcd, " => ", enc)
</syntaxhighlight>
 
{{out}}
<pre>
http://foo bar/ => http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.2
 
import java.net.URLEncoder
 
fun main(args: Array<String>) {
val url = "http://foo bar/"
println(URLEncoder.encode(url, "utf-8")) // note: encodes space to + not %20
}</syntaxhighlight>
 
{{out}}
<pre>
http%3A%2F%2Ffoo+bar%2F
</pre>
 
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
url_encode()
{
printf "%(url)q\n" "$*"
public static void main(String[] args) throws UnsupportedEncodingException
}
{
 
String normal = "http://foo bar/";
 
String encoded = URLEncoder.encode(normal, "utf-8");
url_encode "http://foo bar/"
System.out.println(encoded);
url_encode "https://ru.wikipedia.org/wiki/Транспайлер"
url_encode "google.com/search?q=`Abdu'l-Bahá"
</syntaxhighlight>
 
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
https%3A%2F%2Fru.wikipedia.org%2Fwiki%2F%D0%A2%D1%80%D0%B0%D0%BD%D1%81%D0%BF%D0%B0%D0%B9%D0%BB%D0%B5%D1%80
google.com%2Fsearch%3Fq%3D%60Abdu%27l-Bah%C3%A1
</pre>
 
 
=={{header|langur}}==
<syntaxhighlight lang="langur">
val urlEncode = fn(s) {
replace(
s, re/[^A-Za-z0-9]/,
fn s:join("", map(fn b:"%{{b:X02}}", s2b(s))),
)
}
 
writeln urlEncode("https://some website.com/")
</syntaxhighlight>
 
{{out}}
<pre>https%3A%2F%2Fsome%20website%2Ecom%2F</pre>
 
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">bytes('http://foo bar/') -> encodeurl</syntaxhighlight>
-> http%3A%2F%2Ffoo%20bar%2F
 
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
dim lookUp$( 256)
 
for i =0 to 256
lookUp$( i) ="%" +dechex$( i)
next i
 
string$ ="http://foo bar/"
 
print "Supplied string '"; string$; "'"
print "As URL '"; url$( string$); "'"
 
end
 
function url$( i$)
for j =1 to len( i$)
c$ =mid$( i$, j, 1)
if instr( "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", c$) then
url$ =url$ +c$
else
url$ =url$ +lookUp$( asc( c$))
end if
next j
end function
</syntaxhighlight>
<pre>
Supplied string 'http://foo bar/'
As URL 'http%3A%2F%2Ffoo%20bar%2F'
</pre>
 
=={{header|Lingo}}==
Lingo implements old-school URL encoding (with spaces encoded as "+") out of the box:
 
<syntaxhighlight lang="lingo">put urlencode("http://foo bar/")
-- "http%3a%2f%2ffoo+bar%2f"</syntaxhighlight>
 
For RFC 3986 URL encoding (i.e. without the "+" fuss) a custom function is needed - which might call the above function and then just replace all "+" with "%20".
 
=={{header|LiveCode}}==
<syntaxhighlight lang="livecode">urlEncode("http://foo bar/")
-- http%3A%2F%2Ffoo+bar%2F</syntaxhighlight>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">function encodeChar(chr)
return string.format("%%%X",string.byte(chr))
end
 
function encodeString(str)
local output, t = string.gsub(str,"[^%w]",encodeChar)
return output
end
 
-- will print "http%3A%2F%2Ffoo%20bar%2F"
print(encodeString("http://foo bar/"))</syntaxhighlight>
 
=={{header|M2000 Interpreter}}==
<syntaxhighlight 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)
acc$=str$(a$(0))
While k {
acc$+=str$(Chr$(Eval("0x"+left$(a$(k^),2)))+Mid$(a$(k^),3))
}
=string$(acc$ as utf8dec)
}
Group Parse$ {
all$, c=1
tc$=""
Enum UrlType {None=0, RFC3986, HTML5}
variation
TypeData=("","-._~","-._*")
Function Next {
.tc$<=mid$(.all$,.c,1)
.c++
=.tc$<>""
}
Value {
=.tc$
}
Function DecodeOne$ {
if .tc$="" then exit
if .tc$ ~"[A-Za-z0-9]" then =.tc$ : exit
If .tc$=" " Then =if$(.variation=.HTML5->"+","%20") :exit
if instr(.TypeData#val$(.variation),.tc$)>0 then =.tc$ :exit
="%"+hex$(asc(.tc$), 1)
}
Function Decode$ {
acc$=""
.c<=1
While .Next() {
acc$+=.DecodeOne$()
}
=acc$
}
Set () {
\\ using optional argument
var=.None
Read a$, ? var
a$=chr$(string$(a$ as utf8enc))
.variation<=var
.all$<=a$
.c<=1
}
}
\\ MAIN
Parse$()="http://foo bar/"
Print Quote$(Parse.Decode$())
Parse.variation=Parse.HTML5
Print Quote$(Parse.Decode$())
Parse.variation=Parse.RFC3986
Print Quote$(Parse.Decode$())
Parse$(Parse.RFC3986) ={mailto:"Irma User" <irma.user@mail.com>}
Print Quote$(Parse.Decode$())
Parse$(Parse.RFC3986) ={http://foo.bar.com/~user-name/_subdir/*~.html}
m=each(Parse.UrlType)
while m {
Parse.variation=eval(m)
Print Quote$(Parse.Decode$())
Print decodeUrl$(Parse.Decode$())
}
}
CheckIt
</syntaxhighlight>
<pre style="height:30ex;overflow:scroll">
"http%3A%2F%2Ffoo%20bar%2F"
"http%3A%2F%2Ffoo+bar%2F"
"mailto%3A%22Irma%20User%22%20%3Cirma.user%40mail.com%3E"
"http%3A%2F%2Ffoo%2Ebar%2Ecom%2F%7Euser%2Dname%2F%5Fsubdir%2F%2A%7E%2Ehtml"
"http%3A%2F%2Ffoo.bar.com%2F~user-name%2F_subdir%2F%2A~.html"
"http%3A%2F%2Ffoo.bar.com%2F%7Euser-name%2F_subdir%2F*%7E.html"
 
</pre >
 
=={{header|Maple}}==
<syntaxhighlight lang="maple">URL:-Escape("http://foo bar/");</syntaxhighlight>
 
{{out}}
<pre>"http%3A%2F%2Ffoo%20bar%2F"</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">URLEncoding[url_] :=
StringReplace[url,
x : Except[
Join[CharacterRange["0", "9"], CharacterRange["a", "z"],
CharacterRange["A", "Z"]]] :>
StringJoin[("%" ~~ #) & /@
IntegerString[ToCharacterCode[x, "UTF8"], 16]]]</syntaxhighlight>
Example use:
<syntaxhighlight lang="mathematica">URLEncoding["http://foo bar/"]</syntaxhighlight>
{{out}}
<pre>http%3a%2f%2ffoo%20bar%2f</pre>
 
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab">function u = urlencoding(s)
u = '';
for k = 1:length(s),
if isalnum(s(k))
u(end+1) = s(k);
else
u=[u,'%',dec2hex(s(k)+0)];
end;
end
end</syntaxhighlight>
Usage:
<pre>octave:3> urlencoding('http://foo bar/')
ans = http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|NetRexx}}==
<syntaxhighlight lang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
 
/* -------------------------------------------------------------------------- */
testcase()
say
say 'RFC3986'
testcase('RFC3986')
say
say 'HTML5'
testcase('HTML5')
say
return
 
/* -------------------------------------------------------------------------- */
method encode(url, varn) public static
 
variation = varn.upper
opts = ''
opts['RFC3986'] = '-._~'
opts['HTML5'] = '-._*'
 
rp = ''
loop while url.length > 0
parse url tc +1 url
select
when tc.datatype('A') then do
rp = rp || tc
end
when tc == ' ' then do
if variation = 'HTML5' then
rp = rp || '+'
else
rp = rp || '%' || tc.c2x
end
otherwise do
if opts[variation].pos(tc) > 0 then do
rp = rp || tc
end
else do
rp = rp || '%' || tc.c2x
end
end
end
end
 
return rp
 
/* -------------------------------------------------------------------------- */
method testcase(variation = '') public static
 
url = [ -
'http://foo bar/' -
, 'mailto:"Ivan Aim" <ivan.aim@email.com>' -
, 'mailto:"Irma User" <irma.user@mail.com>' -
, 'http://foo.bar.com/~user-name/_subdir/*~.html' -
]
 
loop i_ = 0 to url.length - 1
say url[i_]
say encode(url[i_], variation)
end i_
 
return
</syntaxhighlight>
 
{{out}}
<pre>
http://foo bar/
http%3A%2F%2Ffoo%20bar%2F
mailto:"Ivan Aim" <ivan.aim@email.com>
mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E
mailto:"Irma User" <irma.user@mail.com>
mailto%3A%22Irma%20User%22%20%3Cirma%2Euser%40mail%2Ecom%3E
http://foo.bar.com/~user-name/_subdir/*~.html
http%3A%2F%2Ffoo%2Ebar%2Ecom%2F%7Euser%2Dname%2F%5Fsubdir%2F%2A%7E%2Ehtml
RFC3986
http://foo bar/
http%3A%2F%2Ffoo%20bar%2F
mailto:"Ivan Aim" <ivan.aim@email.com>
mailto%3A%22Ivan%20Aim%22%20%3Civan.aim%40email.com%3E
mailto:"Irma User" <irma.user@mail.com>
mailto%3A%22Irma%20User%22%20%3Cirma.user%40mail.com%3E
http://foo.bar.com/~user-name/_subdir/*~.html
http%3A%2F%2Ffoo.bar.com%2F~user-name%2F_subdir%2F%2A~.html
HTML5
http://foo bar/
http%3A%2F%2Ffoo+bar%2F
mailto:"Ivan Aim" <ivan.aim@email.com>
mailto%3A%22Ivan+Aim%22+%3Civan.aim%40email.com%3E
mailto:"Irma User" <irma.user@mail.com>
mailto%3A%22Irma+User%22+%3Cirma.user%40mail.com%3E
http://foo.bar.com/~user-name/_subdir/*~.html
http%3A%2F%2Ffoo.bar.com%2F%7Euser-name%2F_subdir%2F*%7E.html
</pre>
 
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">;; simple encoder
;; (source http://www.newlisp.org/index.cgi?page=Code_Snippets)
(define (url-encode str)
(replace {([^a-zA-Z0-9])} str (format "%%%2X" (char $1)) 0))
 
(url-encode "http://foo bar/")</syntaxhighlight>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">import cgi
 
echo encodeUrl("http://foo/bar/")</syntaxhighlight>
 
{{out}}
<pre>http%3A%2F%2Ffoo%2Fbar%2F</pre>
 
=={{header|Oberon-2}}==
{{works with|oo2c}}
<syntaxhighlight lang="oberon2">
MODULE URLEncoding;
IMPORT
Out := NPCT:Console,
ADT:StringBuffer,
URI := URI:String;
VAR
encodedUrl: StringBuffer.StringBuffer;
BEGIN
encodedUrl := NEW(StringBuffer.StringBuffer,512);
URI.AppendEscaped("http://foo bar/","",encodedUrl);
Out.String(encodedUrl.ToString());Out.Ln
END URLEncoding.
</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Objeck}}==
<syntaxhighlight lang="objeck">
use FastCgi;
 
bundle Default {
class UrlEncode {
function : Main(args : String[]) ~ Nil {
url := "http://foo bar/";
UrlUtility->Encode(url)->PrintLine();
}
}
}</lang>
}
</syntaxhighlight>
 
=={{header|Objective-C}}==
Output:
<syntaxhighlight lang="objc">NSString *normal = @"http://foo bar/";
NSString *encoded = [normal stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
NSLog(@"%@", encoded);</syntaxhighlight>
 
The Core Foundation function <code>CFURLCreateStringByAddingPercentEscapes()</code> provides more options.
<pre>http%3A%2F%2Ffoo+bar%2F</pre>
 
{{works with|Mac OS X|10.9+}}
{{works with|iOS|7+}}
<syntaxhighlight lang="objc">NSString *normal = @"http://foo bar/";
NSString *encoded = [normal stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet alphanumericCharacterSet]];
NSLog(@"%@", encoded);</syntaxhighlight>
 
For encoding for various parts of the URL, the allowed character sets <code>[NSCharacterSet URLUserAllowedCharacterSet]</code>, <code>[NSCharacterSet URLPasswordAllowedCharacterSet]</code>, <code>[NSCharacterSet URLHostAllowedCharacterSet]</code>, <code>[NSCharacterSet URLPathAllowedCharacterSet]</code>, <code>[NSCharacterSet URLQueryAllowedCharacterSet]</code>, or <code>[NSCharacterSet URLFragmentAllowedCharacterSet]</code> are provided.
 
=={{header|OCaml}}==
 
Using the library [http://projects.camlcity.org/projects/ocamlnet.html ocamlnet] from the interactive loop:
 
<syntaxhighlight lang="ocaml">$ ocaml
# #use "topfind";;
# #require "netstring";;
 
# Netencoding.Url.encode "http://foo bar/" ;;
- : string = "http%3A%2F%2Ffoo+bar%2F"</syntaxhighlight>
 
=={{header|ooRexx}}==
The solution shown at [[#REXX|Rexx]] (version 1) is a valid ooRexx program.
 
version 2 uses constructs not supported by ooRexx:<br>
url.=; and $ as variable symbol
 
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
##
function URLEncode(s: string) := System.Uri.EscapeDataString(s);
 
Println(URLEncode('http://foo bar/'));
</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Perl}}==
 
<syntaxhighlight lang="perl">sub urlencode {
my $s = shift;
$s =~ s/([^-A-Za-z0-9_.!~*'() ])/sprintf("%%%02X", ord($1))/eg;
$s =~ tr/ /+/;
return $s;
}
 
print urlencode('http://foo bar/')."\n";
</syntaxhighlight>
{{out}}
<pre>http%3A%2F%2Ffoo+bar%2F
</pre>
 
<syntaxhighlight lang="perl">use URI::Escape;
 
my $s = 'http://foo/bar/';
print uri_escape($s);</syntaxhighlight>
 
Use standard CGI module:
<langsyntaxhighlight lang="perl">use 5.10.0;
use CGI;
 
my $s = 'http://foo/bar/';
say $s = CGI::escape($s);
say $s = CGI::unescape($s);</langsyntaxhighlight>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\encode_url.exw
-- ===========================
--</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">nib</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">+</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">9</span><span style="color: #0000FF;">?</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">:</span><span style="color: #008000;">'A'</span><span style="color: #0000FF;">-</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">encode_url</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">exclusions</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">spaceplus</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">=</span><span style="color: #008000;">' '</span> <span style="color: #008080;">and</span> <span style="color: #000000;">spaceplus</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">'+'</span>
<span style="color: #008080;">elsif</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">,</span><span style="color: #000000;">exclusions</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">and</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;"><</span><span style="color: #008000;">'0'</span>
<span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">></span><span style="color: #008000;">'9'</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;"><</span><span style="color: #008000;">'A'</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">></span><span style="color: #008000;">'Z'</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;"><</span><span style="color: #008000;">'a'</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">or</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">></span><span style="color: #008000;">'z'</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">'%'</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">nib</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">/</span><span style="color: #000000;">#10</span><span style="color: #0000FF;">))</span>
<span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">nib</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#0F</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">ch</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">encode_url</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"http://foo bar/"</span><span style="color: #0000FF;">)})</span>
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
{{Out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Perl 6PHP}}==
<syntaxhighlight lang="php"><?php
 
<lang perl6>my $urls = 'http://foo /bar/';
$s = rawurlencode($s);
 
?></syntaxhighlight>
say $url.subst(/<-[ A..Z a..z 0..9 ]>/, *.ord.fmt("%%%02X"), :g);</lang>
There is also <code>urlencode()</code>, which also encodes spaces as "+" signs
 
Output:
<pre>http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de urlEncodeTooMuch (Str)
(pack
(mapcar
Line 115 ⟶ 1,432:
C
(list '% (hex (char C))) ) )
(chop Str) ) ) )</langsyntaxhighlight>
Test:
<pre>: (urlEncodeTooMuch "http://foo bar/")
-> "http%3A%2F%2Ffoo%20bar%2F"</pre>
 
=={{header|Pike}}==
<syntaxhighlight lang="pike">Protocols.HTTP.uri_encode( "http://foo bar/" );</syntaxhighlight>
{{Out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Powershell}}==
<syntaxhighlight lang="powershell">
[uri]::EscapeDataString('http://foo bar/')
 
http%3A%2F%2Ffoo%20bar%2F
</syntaxhighlight>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">URL$ = URLEncoder("http://foo bar/")</langsyntaxhighlight>
 
=={{header|Python}}==
<syntaxhighlight lang="python">import urllib
s = 'http://foo/bar/'
s = urllib.quote(s)</syntaxhighlight>
There is also <code>urllib.quote_plus()</code>, which also encodes spaces as "+" signs
 
=={{header|R}}==
 
R has a built-in
 
<syntaxhighlight lang="r">URLencode("http://foo bar/")</syntaxhighlight>
 
function, but it doesn't fully follow RFC guidelines, so we have to use another R package to accomplish the task:
 
<syntaxhighlight lang="r">
library(RCurl)
curlEscape("http://foo bar/")
</syntaxhighlight>
 
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(require net/uri-codec)
(uri-encode "http://foo bar/")
</syntaxhighlight>
 
=={{header|Raku}}==
(formerly Perl 6)
 
<syntaxhighlight lang="raku" line>my $url = 'http://foo bar/';
 
say $url.subst(/<-alnum>/, *.ord.fmt("%%%02X"), :g);</syntaxhighlight>
 
{{out}}
<pre>http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|REALbasic}}==
Using the built-in encoding method, which doesn't permit exceptions:
<syntaxhighlight lang="vb">
Dim URL As String = "http://foo bar/"
URL = EncodeURLComponent(URL)
Print(URL)
</syntaxhighlight>
 
With optional exceptions. A "ParamArray" is an array of zero or more additional arguments passed by the caller:
<syntaxhighlight lang="vb">
Function URLEncode(Data As String, ParamArray Exceptions() As String) As String
Dim buf As String
For i As Integer = 1 To Data.Len
Dim char As String = Data.Mid(i, 1)
Select Case Asc(char)
Case 48 To 57, 65 To 90, 97 To 122, 45, 46, 95
buf = buf + char
Else
If Exceptions.IndexOf(char) > -1 Then
buf = buf + char
Else
buf = buf + "%" + Left(Hex(Asc(char)) + "00", 2)
End If
End Select
Next
Return buf
End Function
 
'usage
Dim s As String = URLEncode("http://foo bar/") ' no exceptions
Dim t As String = URLEncode("http://foo bar/", "!", "?", ",") ' with exceptions
</syntaxhighlight>
 
=={{header|REXX}}==
===version 1===
<syntaxhighlight lang="rexx">/* Rexx */
do
call testcase
say
say RFC3986
call testcase RFC3986
say
say HTML5
call testcase HTML5
say
return
end
exit
 
/* -------------------------------------------------------------------------- */
encode:
procedure
do
parse arg url, varn .
parse upper var varn variation
drop RFC3986 HTML5
opts. = ''
opts.RFC3986 = '-._~'
opts.HTML5 = '-._*'
 
rp = ''
do while length(url) > 0
parse var url tc +1 url
select
when datatype(tc, 'A') then do
rp = rp || tc
end
when tc == ' ' then do
if variation = HTML5 then
rp = rp || '+'
else
rp = rp || '%' || c2x(tc)
end
otherwise do
if pos(tc, opts.variation) > 0 then do
rp = rp || tc
end
else do
rp = rp || '%' || c2x(tc)
end
end
end
end
 
return rp
end
exit
 
/* -------------------------------------------------------------------------- */
testcase:
procedure
do
parse arg variation
X = 0
url. = ''
X = X + 1; url.0 = X; url.X = 'http://foo bar/'
X = X + 1; url.0 = X; url.X = 'mailto:"Ivan Aim" <ivan.aim@email.com>'
X = X + 1; url.0 = X; url.X = 'mailto:"Irma User" <irma.user@mail.com>'
X = X + 1; url.0 = X; url.X = 'http://foo.bar.com/~user-name/_subdir/*~.html'
 
do i_ = 1 to url.0
say url.i_
say encode(url.i_, variation)
end i_
 
return
end
</syntaxhighlight>
 
{{out}}
<pre>
http://foo bar/
http%3A%2F%2Ffoo%20bar%2F
mailto:"Ivan Aim" <ivan.aim@email.com>
mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E
mailto:"Irma User" <irma.user@mail.com>
mailto%3A%22Irma%20User%22%20%3Cirma%2Euser%40mail%2Ecom%3E
http://foo.bar.com/~user-name/_subdir/*~.html
http%3A%2F%2Ffoo%2Ebar%2Ecom%2F%7Euser%2Dname%2F%5Fsubdir%2F%2A%7E%2Ehtml
 
RFC3986
http://foo bar/
http%3A%2F%2Ffoo%20bar%2F
mailto:"Ivan Aim" <ivan.aim@email.com>
mailto%3A%22Ivan%20Aim%22%20%3Civan.aim%40email.com%3E
mailto:"Irma User" <irma.user@mail.com>
mailto%3A%22Irma%20User%22%20%3Cirma.user%40mail.com%3E
http://foo.bar.com/~user-name/_subdir/*~.html
http%3A%2F%2Ffoo.bar.com%2F~user-name%2F_subdir%2F%2A~.html
 
HTML5
http://foo bar/
http%3A%2F%2Ffoo+bar%2F
mailto:"Ivan Aim" <ivan.aim@email.com>
mailto%3A%22Ivan+Aim%22+%3Civan.aim%40email.com%3E
mailto:"Irma User" <irma.user@mail.com>
mailto%3A%22Irma+User%22+%3Cirma.user%40mail.com%3E
http://foo.bar.com/~user-name/_subdir/*~.html
http%3A%2F%2Ffoo.bar.com%2F%7Euser-name%2F_subdir%2F*%7E.html
</pre>
 
===version 2===
<syntaxhighlight lang="rexx">/*REXX program encodes a URL text, blanks ──► +, preserves -._* and -._~ */
url.=; url.1= 'http://foo bar/'
url.2= 'mailto:"Ivan Aim" <ivan.aim@email.com>'
url.3= 'mailto:"Irma User" <irma.user@mail.com>'
url.4= 'http://foo.bar.com/~user-name/_subdir/*~.html'
do j=1 while url.j\==''; say
say ' original: ' url.j
say ' encoded: ' URLencode(url.j)
end /*j*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
URLencode: procedure; parse arg $,,z; t1= '-._~' /*get args, null Z.*/
skip=0; t2= '-._*'
do k=1 for length($); _=substr($, k, 1) /*get a character. */
if skip\==0 then do; skip=skip-1 /*skip t1 or t2 ? */
iterate /*skip a character.*/
end
select
when datatype(_, 'A') then z=z || _ /*is alphanumeric ?*/
when _==' ' then z=z'+' /*is it a blank ?*/
when substr($, k, 4)==t1 |, /*is it t1 or t2 ?*/
substr($, k, 4)==t2 then do; skip=3 /*skip 3 characters*/
z=z || substr($, k, 4)
end
otherwise z=z'%'c2x(_) /*special character*/
end /*select*/
end /*k*/
return z</syntaxhighlight>
'''output''' &nbsp; when using the default input:
<pre>
original: http://foo bar/
encoded: http%3A%2F%2Ffoo+bar%2F
 
original: mailto:"Ivan Aim" <ivan.aim@email.com>
encoded: mailto%3A%22Ivan+Aim%22+%3Civan%2Eaim%40email%2Ecom%3E
 
original: mailto:"Irma User" <irma.user@mail.com>
encoded: mailto%3A%22Irma+User%22+%3Cirma%2Euser%40mail%2Ecom%3E
 
original: http://foo.bar.com/~user-name/_subdir/*~.html
encoded: http%3A%2F%2Ffoo%2Ebar%2Ecom%2F%7Euser%2Dname%2F%5Fsubdir%2F%2A%7E%2Ehtml
</pre>
 
=={{header|Ruby}}==
<code>CGI.escape</code> encodes all characters except '-.0-9A-Z_a-z'.
 
<syntaxhighlight lang="ruby">require 'cgi'
puts CGI.escape("http://foo bar/").gsub("+", "%20")
# => "http%3A%2F%2Ffoo%20bar%2F"</syntaxhighlight>
 
Programs should not call <code>URI.escape</code> (alias <code>URI.encode</code>), because it fails to encode some characters. <code>URI.escape</code> is [http://www.ruby-forum.com/topic/207489 obsolete] since Ruby 1.9.2.
 
<code>URI.encode_www_form_component</code> is a new method from Ruby 1.9.2. It obeys HTML 5 and encodes all characters except '-.0-9A-Z_a-z' and '*'.
 
{{works with|Ruby|1.9.2}}
<syntaxhighlight lang="ruby">require 'uri'
puts URI.encode_www_form_component("http://foo bar/").gsub("+", "%20")
# => "http%3A%2F%2Ffoo%20bar%2F"</syntaxhighlight>
 
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">urlIn$ = "http://foo bar/"
 
for i = 1 to len(urlIn$)
a$ = mid$(urlIn$,i,1)
if (a$ >= "0" and a$ <= "9") _
or (a$ >= "A" and a$ <= "Z") _
or (a$ >= "a" and a$ <= "z") then url$ = url$ + a$ else url$ = url$ + "%"+dechex$(asc(a$))
next i
print urlIn$;" -> ";url$</syntaxhighlight>
<pre>http://foo bar/ -> http%3A%2F%2Ffoo%20bar%2F</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">const INPUT: &str = "http://foo bar/";
const MAX_CHAR_VAL: u32 = std::char::MAX as u32;
fn main() {
let mut buff = [0; 4];
println!("{}", INPUT.chars()
.map(|ch| {
match ch as u32 {
0 ..= 47 | 58 ..= 64 | 91 ..= 96 | 123 ..= MAX_CHAR_VAL => {
ch.encode_utf8(&mut buff);
buff[0..ch.len_utf8()].iter().map(|&byte| format!("%{:X}", byte)).collect::<String>()
},
_ => ch.to_string(),
}
})
.collect::<String>()
);
}</syntaxhighlight>
{{Out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Scala}}==
{{libheader|Scala}}<syntaxhighlight 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]")
}</syntaxhighlight>
 
=={{header|Seed7}}==
The library [http://seed7.sourceforge.net/libraries/encoding.htm encoding.s7i] defines functions
to handle URL respectively percent encoding.
The function [http://seed7.sourceforge.net/libraries/encoding.htm#toPercentEncoded%28in_string%29 toPercentEncoded]
encodes every character except 0-9, A-Z, a-z and the characters '-', '.', '_', '~'.
The function [http://seed7.sourceforge.net/libraries/encoding.htm#toUrlEncoded%28in_string%29 toUrlEncoded]
works like ''toPercentEncoded'' and additionally encodes a space with '+'.
Both functions work for byte sequences (characters beyond '\255\' raise the exception RANGE_ERROR).
To encode Unicode characters it is necessary to convert them to UTF-8 with [https://seed7.sourceforge.net/libraries/unicode.htm#toUtf8(in_string) toUtf8] before.
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "encoding.s7i";
 
const proc: main is func
begin
writeln(toPercentEncoded("http://foo bar/"));
writeln(toUrlEncoded("http://foo bar/"));
end func;</syntaxhighlight>
{{out}}
http%3A%2F%2Ffoo%20bar%2F
http%3A%2F%2Ffoo+bar%2F
 
=={{header|Sidef}}==
{{trans|Perl}}
<syntaxhighlight lang="ruby">func urlencode(str) {
str.gsub!(%r"([^-A-Za-z0-9_.!~*'() ])", {|a| "%%%02X" % a.ord});
str.gsub!(' ', '+');
return str;
}
 
say urlencode('http://foo bar/');</syntaxhighlight>
{{out}}
<pre>http%3A%2F%2Ffoo+bar%2F</pre>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl"># Encode all except "unreserved" characters; use UTF-8 for extended chars.
# See http://tools.ietf.org/html/rfc3986 §2.4 and §2.5
proc urlEncode {str} {
Line 131 ⟶ 1,786:
set replacement {%[format "%02X" [scan "\\\0" "%c"]]}
return [string map {"\n" "%0A"} [subst [regsub -all $chRE $uStr $replacement]]]
}</langsyntaxhighlight>
Demonstrating:
<langsyntaxhighlight lang="tcl">puts [urlEncode "http://foo bar/"]</langsyntaxhighlight>
{{out}}
Output:
<pre>http%3A%2F%2Ffoo%20bar%2F%E2%82%AC</pre>
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
text="http://foo bar/"
Line 148 ⟶ 1,804:
print "text: ", text
PRINT "encoded: ", url_encoded
</syntaxhighlight>
- Programmfehler: url=ENCODE (url,cgi/utf8)
{{out}}
</lang>
Output:
<pre>
text: http://foo bar/
encoded: http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|UNIX Shell}}==
 
{{works with|bash}}
unfortunately ksh does not support <code>"'$c"</code> syntax
<syntaxhighlight lang="bash">function urlencode
{
typeset decoded=$1 encoded= rest= c=
typeset rest2= bug='rest2=${rest}'
 
if [[ -z ${BASH_VERSION} ]]; then
# bug /usr/bin/sh HP-UX 11.00
typeset _decoded='xyz%26xyz'
rest="${_decoded#?}"
c="${_decoded%%${rest}}"
if (( ${#c} != 1 )); then
typeset qm='????????????????????????????????????????????????????????????????????????'
typeset bug='(( ${#rest} > 0 )) && typeset -L${#rest} rest2="${qm}" || rest2=${rest}'
fi
fi
 
rest="${decoded#?}"
eval ${bug}
c="${decoded%%${rest2}}"
decoded="${rest}"
 
while [[ -n ${c} ]]; do
case ${c} in
[-a-zA-z0-9.])
;;
' ')
c='+'
;;
*)
c=$(printf "%%%02X" "'$c")
;;
esac
 
encoded="${encoded}${c}"
 
rest="${decoded#?}"
eval ${bug}
c="${decoded%%${rest2}}"
decoded="${rest}"
done
 
if [[ -n ${BASH_VERSION:-} ]]; then
\echo -E "${encoded}"
else
print -r -- "${encoded}"
fi
}
</syntaxhighlight>
 
=={{header|VBScript}}==
<syntaxhighlight lang="vbscript">Function UrlEncode(url)
For i = 1 To Len(url)
n = Asc(Mid(url,i,1))
If (n >= 48 And n <= 57) Or (n >= 65 And n <= 90) _
Or (n >= 97 And n <= 122) Then
UrlEncode = UrlEncode & Mid(url,i,1)
Else
ChrHex = Hex(Asc(Mid(url,i,1)))
For j = 0 to (Len(ChrHex) / 2) - 1
UrlEncode = UrlEncode & "%" & Mid(ChrHex,(2*j) + 1,2)
Next
End If
Next
End Function
 
WScript.Echo UrlEncode("http://foo baré/")</syntaxhighlight>
 
{{out}}
<pre>http%3A%2F%2Ffoo%20bar%C3%A9%2F</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import net.urllib
fn main() {
println(urllib.query_escape("http://foo bar/"))
}</syntaxhighlight>
{{out}}
<pre>
http%3A%2F%2Ffoo+bar%2F
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
 
var urlEncode = Fn.new { |url|
var res = ""
for (b in url.bytes) {
if ((b >= 48 && b <= 57) || (b >= 65 && b <= 90) || (b >= 97 && b <= 122)) {
res = res + String.fromByte(b)
} else {
res = res + Fmt.swrite("\%$2X", b)
}
}
return res
}
 
var urls = [
"http://foo bar/",
"mailto:\"Ivan Aim\" <ivan.aim@email.com>",
"mailto:\"Irma User\" <irma.user@mail.com>",
"http://foo.bar.com/~user-name/_subdir/*~.html"
]
for (url in urls) System.print(urlEncode.call(url))</syntaxhighlight>
 
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
mailto%3A%22Ivan%20Aim%22%20%3Civan%2Eaim%40email%2Ecom%3E
mailto%3A%22Irma%20User%22%20%3Cirma%2Euser%40mail%2Ecom%3E
http%3A%2F%2Ffoo%2Ebar%2Ecom%2F%7Euser%2Dname%2F%5Fsubdir%2F%2A%7E%2Ehtml
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">code Text=12;
string 0; \use zero-terminated strings
 
func Encode(S0); \Encode URL string and return its address
char S0;
char HD, S1(80); \BEWARE: very temporary string space returned
int C, I, J;
[HD:= "0123456789ABCDEF"; \hex digits
I:= 0; J:= 0;
repeat C:= S0(I); I:= I+1;
if C>=^0 & C<=^9 ! C>=^A & C<=^Z ! C>=^a & C<=^z ! C=0
then [S1(J):= C; J:= J+1] \simply pass char to S1
else [S1(J):= ^%; J:= J+1; \encode char into S1
S1(J):= HD(C>>4); J:= J+1;
S1(J):= HD(C&$0F); J:= J+1;
];
until C=0;
return S1;
];
 
Text(0, Encode("http://foo bar/"))</syntaxhighlight>
 
{{out}}
<pre>
http%3A%2F%2Ffoo%20bar%2F
</pre>
 
=={{header|Yabasic}}==
{{trans|Phix}}
<syntaxhighlight lang="yabasic">sub encode_url$(s$, exclusions$, spaceplus)
local res$, i, ch$
for i=1 to len(s$)
ch$ = mid$(s$, i, 1)
if ch$ = " " and spaceplus then
ch$ = "+"
elsif not instr(esclusions$, ch$) and (ch$ < "0" or (ch$ > "9" and ch$ < "A") or (ch$ > "Z" and ch$ < "a") or ch$ > "z") then
res$ = res$ + "%"
ch$ = upper$(hex$(asc(ch$)))
end if
res$ = res$ + ch$
next i
return res$
end sub
 
print encode_url$("http://foo bar/")</syntaxhighlight>
 
=={{header|zkl}}==
Using lib cURL:
<syntaxhighlight lang="zkl">var CURL=Import("zklCurl");
CURL.urlEncode("http://foo bar/") //--> "http%3A%2F%2Ffoo%20bar%2F"</syntaxhighlight>
Langurmonkey
1,007

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/189224...365384"