URL encoding: Difference between revisions

;Variations:

* Lowercase escapes are legal, as in "<code><nowiki>http%3a%2f%2ffoo%20bar%2f</nowiki></code>".

 

;Options:

 

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

V r = ‘’

V buf = ‘’

 

print(url_encode(‘http://foo bar/’))

 

{{out}}

 

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

BYTE i

 

Test("http://www.rosettacode.org/wiki/URL_encoding")

Test("http://foo bar/*_-.html")

{{out}}

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

=={{header|Ada}}==

{{libheader|AWS}}

with Ada.Text_IO; use Ada.Text_IO;

procedure Encode is

begin

Put_Line (AWS.URL.Encode (Normal));

{{out}}

<pre>http%3A%2F%2Ffoo%20bar%2F</pre>

 

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

# encodes the specified url - 0-9, A-Z and a-z are unchanged, #

# everything else is converted to %xx where xx are hex-digits #

print( ( encode url( "http://foo bar/" ), newline ) )

END

{{out}}

<pre>

 

=={{header|Apex}}==

<pre>http%3A%2F%2Ffoo+bar%2F</pre>

 

=={{header|AppleScript}}==

{{libheader|AppleScript Toolbox}}

{{out}}

<pre>"http%3A%2F%2Ffoo%20bar%2F"</pre>

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AutoHotkey}}==

 

; Modified from http://goo.gl/0a0iJq

VarSetCapacity(Var, StrPut(Uri, "UTF-8"), 0)

StrPut(Uri, &Var, "UTF-8")

 

=={{header|AWK}}==

for (i = 0; i <= 255; i++)

ord[sprintf("%c", i)] = i

 

# Escape every line of input.

 

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|BBC BASIC}}==

END

ENDIF

ENDWHILE

{{out}}

<pre>

 

=={{header|Bracmat}}==

= encoded exceptions octet string

. !arg:(?exceptions.?string)

& out$(encode$("-._~"."http://foo.bar.com/~user-name/_subdir/*~.html"))

);

{{out}}

<pre>without exceptions:

 

=={{header|C}}==

#include <ctype.h>

return 0;

 

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

 

 

namespace URLEncode

}

}

 

{{out}}

=={{header|C++}}==

using Qt 4.6 as a library

#include <iostream>

 

std::cout << encoded.data( ) << '\n' ;

return 0 ;

{{out}}

<PRE>http%3A%2F%2Ffoo%20bar%2F</PRE>

=={{header|Clojure}}==

Using Java's URLEncoder:

 

{{out}}<pre>"http%3A%2F%2Ffoo+bar%2F"</pre>

 

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

(not (digit-char-p char 36)))

 

url)))

 

{{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.

 

puts URI.encode("http://foo bar/")

puts URI.encode("http://foo bar/", space_to_plus: true)

puts URI.encode_www_form("http://foo bar/")

{{out}}

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

 

=={{header|D}}==

 

void main() {

writeln(encodeComponent("http://foo bar/"));

<pre>http%3A%2F%2Ffoo%20bar%2F</pre>

 

=={{header|Elixir}}==

 

=={{header|Erlang}}==

 

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

 

[<EntryPoint>]

let main args =

printfn "%s" (Uri.EscapeDataString(args.[0]))

{{out}}

<pre>>URLencoding.exe "http://foo bar/"

=={{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.

 

: my-url-encode ( str -- encoded )

[ { [ alpha? ] [ "-._~" member? ] } 1|| ] (url-encode) ;

 

{{out}}

<pre>

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

 

var

ch: AnsiChar;

Result := Result + ch;

end;

 

 

=={{header|FreeBASIC}}==

{{trans|Liberty BASIC}}

Dim Shared As String lookUp(256)

For cadena As Integer = 0 To 256

Print "URL encoding '"; string2url(URL); "'"

Sleep

{{out}}

<pre>Supplied URL 'http://foo bar/'

URL encoding 'http%3A%2F%2Ffoo%20bar%2F'</pre>

 

 

=={{header|Go}}==

 

import (

func main() {

fmt.Println(url.QueryEscape("http://foo bar/"))

{{out}}

<pre>

http%3A%2F%2Ffoo+bar%2F

</pre>

 

=={{header|Groovy}}==

def normal = "http://foo bar/"

def encoded = URLEncoder.encode(normal, "utf-8")

println encoded

{{out}}

<pre>

 

=={{header|Haskell}}==

import Text.Printf

 

 

main :: IO ()

{{out}}

<pre>http%3A%2F%2Ffoo+bar%2F</pre>

 

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

 

procedure main()

return c

end

 

{{libheader|Icon Programming Library}}

Here's an implementation that does that:

 

 

Example use:

 

 

=={{header|Java}}==

import java.net.URLEncoder;

}

 

 

=={{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.

 

=={{header|jq}}==

 

Note that @uri also converts multibyte characters to multi-triplets, e.g.

# The helper function checks whether the input corresponds to one of the characters: !'()*

def recode: . as $c | [33,39,40,41,42] | index($c);

# 37 ==> "%", 50 ==> "2"

| map( if recode then (37, 50, ((. - 32) | hex)) else . end )

'''Examples:'''

 

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

 

 

To contrast the difference between "@uri" and "url_encode", we compare the characters that are unaltered:

 

produces: "!'()*-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

 

produces: "-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

 

=={{header|Julia}}==

//version 1.0.1

import HTTP.URIs: escapeuri

 

println(dcd, " => ", enc)

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.net.URLEncoder

val url = "http://foo bar/"

println(URLEncoder.encode(url, "utf-8")) // note: encodes space to + not %20

 

{{out}}

 

=={{header|Ksh}}==

url_encode()

{

url_encode "https://ru.wikipedia.org/wiki/Транспайлер"

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

 

{{out}}

 

=={{header|langur}}==

 

 

{{out}}

 

=={{header|Lasso}}==

-> http%3A%2F%2Ffoo%20bar%2F

 

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

dim lookUp$( 256)

 

next j

end function

<pre>

Supplied string 'http://foo bar/'

Lingo implements old-school URL encoding (with spaces encoded as "+") out of the box:

 

 

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}}==

 

=={{header|Lua}}==

return string.format("%%%X",string.byte(chr))

end

 

-- will print "http%3A%2F%2Ffoo%20bar%2F"

 

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

Module Checkit {

Function decodeUrl$(a$) {

}

CheckIt

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

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

 

=={{header|Maple}}==

 

{{out}}

 

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

StringReplace[url,

x : Except[

CharacterRange["A", "Z"]]] :>

StringJoin[("%" ~~ #) & /@

Example use:

{{out}}

<pre>http%3a%2f%2ffoo%20bar%2f</pre>

 

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

u = '';

for k = 1:length(s),

end;

end

Usage:

<pre>octave:3> urlencoding('http://foo bar/')

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

return

 

{{out}}

 

=={{header|NewLISP}}==

;; (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))

 

 

=={{header|Nim}}==

 

 

{{out}}

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

{{works with|oo2c}}

MODULE URLEncoding;

IMPORT

Out.String(encodedUrl.ToString());Out.Ln

END URLEncoding.

{{out}}

<pre>

 

=={{header|Objeck}}==

use FastCgi;

 

}

}

 

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

NSString *encoded = [normal stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

 

The Core Foundation function <code>CFURLCreateStringByAddingPercentEscapes()</code> provides more options.

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

{{works with|iOS|7+}}

NSString *encoded = [normal stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet alphanumericCharacterSet]];

 

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.

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

 

# #use "topfind";;

# #require "netstring";;

 

# Netencoding.Url.encode "http://foo bar/" ;;

 

=={{header|ooRexx}}==

=={{header|Perl}}==

 

my $s = shift;

$s =~ s/([^-A-Za-z0-9_.!~*'() ])/sprintf("%%%02X", ord($1))/eg;

 

print urlencode('http://foo bar/')."\n";

{{out}}

<pre>http%3A%2F%2Ffoo+bar%2F

</pre>

 

 

my $s = 'http://foo/bar/';

 

Use standard CGI module:

use CGI;

 

my $s = 'http://foo/bar/';

say $s = CGI::escape($s);

 

=={{header|Phix}}==

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

-- demo\rosetta\encode_url.exw

<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>

{{Out}}

<pre>

 

=={{header|PHP}}==

$s = 'http://foo/bar/';

$s = rawurlencode($s);

There is also <code>urlencode()</code>, which also encodes spaces as "+" signs

 

=={{header|PicoLisp}}==

(pack

(mapcar

C

(list '% (hex (char C))) ) )

Test:

<pre>: (urlEncodeTooMuch "http://foo bar/")

 

=={{header|Pike}}==

{{Out}}

<pre>

 

=={{header|Powershell}}==

[uri]::EscapeDataString('http://foo bar/')

 

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

 

=={{header|PureBasic}}==

 

=={{header|Python}}==

s = 'http://foo/bar/'

There is also <code>urllib.quote_plus()</code>, which also encodes spaces as "+" signs

 

R has a built-in

 

 

function, but it doesn't fully follow RFC guidelines, so we have to use another R package to accomplish the task:

 

library(RCurl)

curlEscape("http://foo bar/")

 

=={{header|Racket}}==

#lang racket

(require net/uri-codec)

(uri-encode "http://foo bar/")

 

=={{header|Raku}}==

(formerly Perl 6)

 

 

 

{{out}}

=={{header|REALbasic}}==

Using the built-in encoding method, which doesn't permit exceptions:

Dim URL As String = "http://foo bar/"

URL = EncodeURLComponent(URL)

Print(URL)

 

With optional exceptions. A "ParamArray" is an array of zero or more additional arguments passed by the caller:

Function URLEncode(Data As String, ParamArray Exceptions() As String) As String

Dim buf As String

Dim s As String = URLEncode("http://foo bar/") ' no exceptions

Dim t As String = URLEncode("http://foo bar/", "!", "?", ",") ' with exceptions

 

=={{header|REXX}}==

===version 1===

do

call testcase

return

end

 

{{out}}

 

===version 2===

url.=; url.1= 'http://foo bar/'

url.2= 'mailto:"Ivan Aim" <ivan.aim@email.com>'

end /*select*/

end /*k*/

'''output''' &nbsp; when using the default input:

<pre>

<code>CGI.escape</code> encodes all characters except '-.0-9A-Z_a-z'.

 

puts CGI.escape("http://foo bar/").gsub("+", "%20")

 

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.

 

{{works with|Ruby|1.9.2}}

puts URI.encode_www_form_component("http://foo bar/").gsub("+", "%20")

 

=={{header|Run BASIC}}==

 

for i = 1 to len(urlIn$)

or (a$ >= "a" and a$ <= "z") then url$ = url$ + a$ else url$ = url$ + "%"+dechex$(asc(a$))

next i

<pre>http://foo bar/ -> http%3A%2F%2Ffoo%20bar%2F</pre>

 

=={{header|Rust}}==

const MAX_CHAR_VAL: u32 = std::char::MAX as u32;

.collect::<String>()

);

{{Out}}

<pre>

 

=={{header|Scala}}==

import scala.compat.Platform.currentTime

 

 

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

 

=={{header|Seed7}}==

works like ''toPercentEncoded'' and additionally encodes a space with '+'.

Both functions work for byte sequences (characters beyond '\255\' raise the exception RANGE_ERROR).

include "encoding.s7i";

 

writeln(toPercentEncoded("http://foo bar/"));

writeln(toUrlEncoded("http://foo bar/"));

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

http%3A%2F%2Ffoo+bar%2F

=={{header|Sidef}}==

{{trans|Perl}}

str.gsub!(%r"([^-A-Za-z0-9_.!~*'() ])", {|a| "%%%02X" % a.ord});

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

}

 

{{out}}

<pre>http%3A%2F%2Ffoo+bar%2F</pre>

 

=={{header|Tcl}}==

# See http://tools.ietf.org/html/rfc3986 §2.4 and §2.5

proc urlEncode {str} {

set replacement {%[format "%02X" [scan "\\\0" "%c"]]}

return [string map {"\n" "%0A"} [subst [regsub -all $chRE $uStr $replacement]]]

Demonstrating:

{{out}}

<pre>http%3A%2F%2Ffoo%20bar%2F%E2%82%AC</pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

text="http://foo bar/"

print "text: ", text

PRINT "encoded: ", url_encoded

{{out}}

<pre>

{{works with|bash}}

unfortunately ksh does not support <code>"'$c"</code> syntax

{

typeset decoded=$1 encoded= rest= c=

fi

}

 

=={{header|VBScript}}==

For i = 1 To Len(url)

n = Asc(Mid(url,i,1))

End Function

 

 

{{out}}

<pre>http%3A%2F%2Ffoo%20bar%C3%A9%2F</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var urlEncode = Fn.new { |url|

"http://foo.bar.com/~user-name/_subdir/*~.html"

]

 

{{out}}

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

];

 

 

{{out}}

=={{header|Yabasic}}==

{{trans|Phix}}

local res$, i, ch$

end sub

 

 

=={{header|zkl}}==

Using lib cURL: