Base64 decode data: Difference between revisions
Thundergnat (talk | contribs) |
Thundergnat (talk | contribs) m (Automated syntax highlighting fixup (second round - minor fixes)) |
||
Line 8: | Line 8: | ||
=={{header|Action!}}== |
=={{header|Action!}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="action!">BYTE FUNC FindIndex(BYTE b) |
||
IF b>='A AND b<='Z THEN |
IF b>='A AND b<='Z THEN |
||
RETURN (b-'A) |
RETURN (b-'A) |
||
Line 95: | Line 95: | ||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
{{libheader|AWS}} |
{{libheader|AWS}} |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="ada">with Ada.Text_IO; |
||
with AWS.Translator; |
with AWS.Translator; |
||
Line 118: | Line 118: | ||
=={{header|Arturo}}== |
=={{header|Arturo}}== |
||
<syntaxhighlight lang=rebol>text: "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
<syntaxhighlight lang="rebol">text: "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
||
print decode text</syntaxhighlight> |
print decode text</syntaxhighlight> |
||
Line 129: | Line 129: | ||
=={{header|BaCon}}== |
=={{header|BaCon}}== |
||
Using the result from the [[Base64 encode data]] task as requested, but the result is abbreviated in the code below. |
Using the result from the [[Base64 encode data]] task as requested, but the result is abbreviated in the code below. |
||
<syntaxhighlight lang=bacon>data$ = "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAE.......QAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=" |
<syntaxhighlight lang="bacon">data$ = "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAE.......QAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=" |
||
ico$ = B64DEC$(data$) |
ico$ = B64DEC$(data$) |
||
BSAVE ico$ TO "favicon.ico" SIZE LEN(ico$)</syntaxhighlight> |
BSAVE ico$ TO "favicon.ico" SIZE LEN(ico$)</syntaxhighlight> |
||
Line 135: | Line 135: | ||
=={{header|Bash}}== |
=={{header|Bash}}== |
||
{{trans|Bash}} |
{{trans|Bash}} |
||
<syntaxhighlight lang=bash>#! /bin/bash |
<syntaxhighlight lang="bash">#! /bin/bash |
||
declare -a encodeTable=( |
declare -a encodeTable=( |
||
# + , - . / 0 1 2 3 4 5 6 7 8 9 : |
# + , - . / 0 1 2 3 4 5 6 7 8 9 : |
||
Line 193: | Line 193: | ||
=={{header|C}}== |
=={{header|C}}== |
||
{{trans|C++}} |
{{trans|C++}} |
||
<syntaxhighlight lang=c>#include <stdio.h> |
<syntaxhighlight lang="c">#include <stdio.h> |
||
#include <stdlib.h> |
#include <stdlib.h> |
||
Line 280: | Line 280: | ||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
{{trans|Visual Basic .NET}} |
{{trans|Visual Basic .NET}} |
||
<syntaxhighlight lang=csharp>using System; |
<syntaxhighlight lang="csharp">using System; |
||
using System.Text; |
using System.Text; |
||
Line 303: | Line 303: | ||
=={{header|C++}}== |
=={{header|C++}}== |
||
{{Works with|C++14}} |
{{Works with|C++14}} |
||
<syntaxhighlight lang=cpp>#include <algorithm> |
<syntaxhighlight lang="cpp">#include <algorithm> |
||
#include <iostream> |
#include <iostream> |
||
#include <string> |
#include <string> |
||
Line 435: | Line 435: | ||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
<syntaxhighlight lang=clojure>(defn decode [str] |
<syntaxhighlight lang="clojure">(defn decode [str] |
||
(String. (.decode (java.util.Base64/getDecoder) str))) |
(String. (.decode (java.util.Base64/getDecoder) str))) |
||
Line 449: | Line 449: | ||
Similar to the [http://rosettacode.org/wiki/Base64_encode_data#Common_Lisp BASE64 encoding task] I am using the [http://quickdocs.org/cl-base64/ cl-base64] library. |
Similar to the [http://rosettacode.org/wiki/Base64_encode_data#Common_Lisp BASE64 encoding task] I am using the [http://quickdocs.org/cl-base64/ cl-base64] library. |
||
<syntaxhighlight lang=lisp>(eval-when (:load-toplevel :compile-toplevel :execute) |
<syntaxhighlight lang="lisp">(eval-when (:load-toplevel :compile-toplevel :execute) |
||
(ql:quickload "cl-base64")) |
(ql:quickload "cl-base64")) |
||
Line 477: | Line 477: | ||
=={{header|Crystal}}== |
=={{header|Crystal}}== |
||
<syntaxhighlight lang=ruby>require "base64" |
<syntaxhighlight lang="ruby">require "base64" |
||
encoded_string = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
encoded_string = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
||
Line 491: | Line 491: | ||
=={{header|D}}== |
=={{header|D}}== |
||
{{trans|Raku}} |
{{trans|Raku}} |
||
<syntaxhighlight lang=d>import std.base64; |
<syntaxhighlight lang="d">import std.base64; |
||
import std.stdio; |
import std.stdio; |
||
Line 509: | Line 509: | ||
=={{header|Dart}}== |
=={{header|Dart}}== |
||
<syntaxhighlight lang=dart>import 'dart:convert'; |
<syntaxhighlight lang="dart">import 'dart:convert'; |
||
void main() { |
void main() { |
||
Line 524: | Line 524: | ||
=={{header|Delphi}}== |
=={{header|Delphi}}== |
||
<syntaxhighlight lang=delphi>program Base64Decoder; |
<syntaxhighlight lang="delphi">program Base64Decoder; |
||
{$APPTYPE CONSOLE} |
{$APPTYPE CONSOLE} |
||
Line 549: | Line 549: | ||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
===Standard Library=== |
===Standard Library=== |
||
<syntaxhighlight lang=fsharp> |
<syntaxhighlight lang="fsharp"> |
||
open System |
open System |
||
open System.IO |
open System.IO |
||
Line 563: | Line 563: | ||
===Manual Implementation=== |
===Manual Implementation=== |
||
<syntaxhighlight lang=fsharp> |
<syntaxhighlight lang="fsharp"> |
||
open System |
open System |
||
open System.IO |
open System.IO |
||
Line 595: | Line 595: | ||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
<syntaxhighlight lang=factor>USING: base64 io strings ; |
<syntaxhighlight lang="factor">USING: base64 io strings ; |
||
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |
||
Line 613: | Line 613: | ||
Inspired from Wikipedia. Use of a buffer. |
Inspired from Wikipedia. Use of a buffer. |
||
May be also of interest : github.com/lietho/base64-forth |
May be also of interest : github.com/lietho/base64-forth |
||
<syntaxhighlight lang=forth>variable bitsbuff |
<syntaxhighlight lang="forth">variable bitsbuff |
||
: char>6bits ( c -- u ) |
: char>6bits ( c -- u ) |
||
Line 670: | Line 670: | ||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
<syntaxhighlight lang=freebasic>Dim Shared As String B64 |
<syntaxhighlight lang="freebasic">Dim Shared As String B64 |
||
B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _ |
B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _ |
||
"abcdefghijklmnopqrstuvwxyz" & _ |
"abcdefghijklmnopqrstuvwxyz" & _ |
||
Line 714: | Line 714: | ||
=={{header|Go}}== |
=={{header|Go}}== |
||
As images can no longer be uploaded to RC, I've encoded and decoded a string rather than the Rosetta Code icon. |
As images can no longer be uploaded to RC, I've encoded and decoded a string rather than the Rosetta Code icon. |
||
<syntaxhighlight lang=go>package main |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 745: | Line 745: | ||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
{{trans|Java}} |
{{trans|Java}} |
||
<syntaxhighlight lang=groovy>import java.nio.charset.StandardCharsets |
<syntaxhighlight lang="groovy">import java.nio.charset.StandardCharsets |
||
class Decode { |
class Decode { |
||
Line 762: | Line 762: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
Simple implementation that decodes an ASCII string. |
Simple implementation that decodes an ASCII string. |
||
<syntaxhighlight lang=haskell>--Decodes Base64 to ASCII |
<syntaxhighlight lang="haskell">--Decodes Base64 to ASCII |
||
import qualified Data.Map.Strict as Map (Map, lookup, fromList) |
import qualified Data.Map.Strict as Map (Map, lookup, fromList) |
||
import Data.Maybe (fromJust, listToMaybe, mapMaybe) |
import Data.Maybe (fromJust, listToMaybe, mapMaybe) |
||
Line 810: | Line 810: | ||
or in terms of Data.ByteString.Base64: |
or in terms of Data.ByteString.Base64: |
||
<syntaxhighlight lang=haskell>{-# LANGUAGE OverloadedStrings #-} |
<syntaxhighlight lang="haskell">{-# LANGUAGE OverloadedStrings #-} |
||
import qualified Data.ByteString.Base64 as Base64 (decode, encode) |
import qualified Data.ByteString.Base64 as Base64 (decode, encode) |
||
Line 833: | Line 833: | ||
=={{header|Haxe}}== |
=={{header|Haxe}}== |
||
<syntaxhighlight lang=haxe>class Main { |
<syntaxhighlight lang="haxe">class Main { |
||
static function main() { |
static function main() { |
||
var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" + |
var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" + |
||
Line 850: | Line 850: | ||
using J's [https://github.com/jsoftware/convert_misc/blob/master/base64.ijs convert/misc/base64] script: |
using J's [https://github.com/jsoftware/convert_misc/blob/master/base64.ijs convert/misc/base64] script: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="j"> require'convert/misc/base64' |
||
frombase64 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=' |
frombase64 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=' |
||
To err is human, but to really foul things up you need a computer. |
To err is human, but to really foul things up you need a computer. |
||
Line 857: | Line 857: | ||
Alternative implementation based on that script: |
Alternative implementation based on that script: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="j"> |
||
BASE64=: (a.{~ ,(a.i.'Aa') +/i.26),'0123456789+/' |
BASE64=: (a.{~ ,(a.i.'Aa') +/i.26),'0123456789+/' |
||
Line 868: | Line 868: | ||
=={{header|Java}}== |
=={{header|Java}}== |
||
{{trans|Kotlin}} |
{{trans|Kotlin}} |
||
<syntaxhighlight lang=java>import java.nio.charset.StandardCharsets; |
<syntaxhighlight lang="java">import java.nio.charset.StandardCharsets; |
||
import java.util.Base64; |
import java.util.Base64; |
||
Line 886: | Line 886: | ||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
=== Browser === |
=== Browser === |
||
<syntaxhighlight lang=javascript>// define base64 data; in this case the data is the string: "Hello, world!" |
<syntaxhighlight lang="javascript">// define base64 data; in this case the data is the string: "Hello, world!" |
||
const base64 = 'SGVsbG8sIHdvcmxkIQ=='; |
const base64 = 'SGVsbG8sIHdvcmxkIQ=='; |
||
// atob is a built-in function. |
// atob is a built-in function. |
||
console.log(atob(base64));</syntaxhighlight> |
console.log(atob(base64));</syntaxhighlight> |
||
=== Node.js === |
=== Node.js === |
||
<syntaxhighlight lang=javascript>// define base64 data; in this case the data is the string: "Hello, world!" |
<syntaxhighlight lang="javascript">// define base64 data; in this case the data is the string: "Hello, world!" |
||
const base64 = Buffer.from('SGVsbG8sIHdvcmxkIQ==', 'base64'); |
const base64 = Buffer.from('SGVsbG8sIHdvcmxkIQ==', 'base64'); |
||
// <Buffer>.toString() is a built-in method. |
// <Buffer>.toString() is a built-in method. |
||
Line 907: | Line 907: | ||
See [[Base64_encode_data#Jsish]] for ''base64.jsi''. |
See [[Base64_encode_data#Jsish]] for ''base64.jsi''. |
||
<syntaxhighlight lang=javascript>/* Base64 decode, in Jsish */ |
<syntaxhighlight lang="javascript">/* Base64 decode, in Jsish */ |
||
var data = exec('jsish base64.jsi', {retAll:true}).data; // or use File.read('stdin'); |
var data = exec('jsish base64.jsi', {retAll:true}).data; // or use File.read('stdin'); |
||
var icon = Util.base64(data, true); |
var icon = Util.base64(data, true); |
||
Line 914: | Line 914: | ||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
Using an IOBuffer here, though not really needed to decode a string, shows how we could pipe a network stream or file though Julia's builtin Base64 decoder. |
Using an IOBuffer here, though not really needed to decode a string, shows how we could pipe a network stream or file though Julia's builtin Base64 decoder. |
||
<syntaxhighlight lang=julia>using Base64 |
<syntaxhighlight lang="julia">using Base64 |
||
io = IOBuffer() |
io = IOBuffer() |
||
Line 933: | Line 933: | ||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
{{trans|D}} |
{{trans|D}} |
||
<syntaxhighlight lang=scala>import java.util.Base64 |
<syntaxhighlight lang="scala">import java.util.Base64 |
||
fun main() { |
fun main() { |
||
Line 948: | Line 948: | ||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
<syntaxhighlight lang=lua>-- Start taken from https://stackoverflow.com/a/35303321 |
<syntaxhighlight lang="lua">-- Start taken from https://stackoverflow.com/a/35303321 |
||
local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' -- You will need this for encoding/decoding |
local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' -- You will need this for encoding/decoding |
||
Line 981: | Line 981: | ||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="mathematica">ImportString[ |
||
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo", |
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo", |
||
"Base64" |
"Base64" |
||
Line 990: | Line 990: | ||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="nim">import base64 |
||
const Source = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
const Source = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
||
Line 1,009: | Line 1,009: | ||
=={{header|Ol}}== |
=={{header|Ol}}== |
||
<syntaxhighlight lang=scheme> |
<syntaxhighlight lang="scheme"> |
||
(define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") |
(define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") |
||
(define kernel (alist->ff (map cons (string->bytes base64-codes) (iota (string-length base64-codes))))) |
(define kernel (alist->ff (map cons (string->bytes base64-codes) (iota (string-length base64-codes))))) |
||
Line 1,059: | Line 1,059: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
The MIME::Base64 module is to be preferred, but this works too. |
The MIME::Base64 module is to be preferred, but this works too. |
||
<syntaxhighlight lang=perl>sub decode_base64 { |
<syntaxhighlight lang="perl">sub decode_base64 { |
||
my($d) = @_; |
my($d) = @_; |
||
$d =~ tr!A-Za-z0-9+/!!cd; |
$d =~ tr!A-Za-z0-9+/!!cd; |
||
Line 1,086: | Line 1,086: | ||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
<!--<syntaxhighlight lang= |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
||
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">base64</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span> |
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">base64</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span> |
||
Line 1,101: | Line 1,101: | ||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="php">$encoded = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw' . |
||
'IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='; |
'IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='; |
||
echo |
echo |
||
Line 1,112: | Line 1,112: | ||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="picolisp">(setq *Char64 |
||
`'(chop |
`'(chop |
||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) ) |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) ) |
||
Line 1,145: | Line 1,145: | ||
By necessity this also implements all of the Base64 encode task to |
By necessity this also implements all of the Base64 encode task to |
||
avoid a humongous amount of icon data hardcoded in the program. |
avoid a humongous amount of icon data hardcoded in the program. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="pike"> |
||
string icon = Protocols.HTTP.get_url_data("http://rosettacode.org/favicon.ico"); |
string icon = Protocols.HTTP.get_url_data("http://rosettacode.org/favicon.ico"); |
||
string encoded = MIME.encode_base64(icon); |
string encoded = MIME.encode_base64(icon); |
||
Line 1,164: | Line 1,164: | ||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="purebasic">b64cd$ = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" + |
||
"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" |
||
Line 1,176: | Line 1,176: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="python"> |
||
import base64 |
import base64 |
||
data = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=' |
data = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=' |
||
Line 1,187: | Line 1,187: | ||
</pre> |
</pre> |
||
=={{header|QB64}}== |
=={{header|QB64}}== |
||
<syntaxhighlight lang=vb>Option _Explicit |
<syntaxhighlight lang="vb">Option _Explicit |
||
Dim As String udata, decoded |
Dim As String udata, decoded |
||
Line 1,309: | Line 1,309: | ||
{{works with|R|4.1.0}} |
{{works with|R|4.1.0}} |
||
{{libheader|base64enc}} |
{{libheader|base64enc}} |
||
<syntaxhighlight lang=rsplus> |
<syntaxhighlight lang="rsplus"> |
||
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |> |
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |> |
||
base64enc::base64decode() |> |
base64enc::base64decode() |> |
||
Line 1,324: | Line 1,324: | ||
{{works with|Rakudo|2018.11}} |
{{works with|Rakudo|2018.11}} |
||
<syntaxhighlight lang=raku line>my $e64 = ' |
<syntaxhighlight lang="raku" line>my $e64 = ' |
||
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 |
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 |
||
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
||
Line 1,360: | Line 1,360: | ||
=={{header|Red}}== |
=={{header|Red}}== |
||
<syntaxhighlight lang=red>Red [Source: https://github.com/vazub/rosetta-red] |
<syntaxhighlight lang="red">Red [Source: https://github.com/vazub/rosetta-red] |
||
print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |
print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |
||
Line 1,371: | Line 1,371: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
<syntaxhighlight lang=ring> |
<syntaxhighlight lang="ring"> |
||
#======================================# |
#======================================# |
||
# Sample: Base64 decode data |
# Sample: Base64 decode data |
||
Line 1,395: | Line 1,395: | ||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
<syntaxhighlight lang=ruby>require 'base64' |
<syntaxhighlight lang="ruby">require 'base64' |
||
raku_example =' |
raku_example =' |
||
Line 1,409: | Line 1,409: | ||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
<syntaxhighlight lang=rust>use std::str; |
<syntaxhighlight lang="rust">use std::str; |
||
const INPUT: &str = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"; |
const INPUT: &str = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"; |
||
Line 1,456: | Line 1,456: | ||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
{{Out}}Best seen in running your browser either by [https://scalafiddle.io/sf/mjgxJDp/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/P4RfGhRQSkaKWEmdBi1gaw Scastie (remote JVM)]. |
{{Out}}Best seen in running your browser either by [https://scalafiddle.io/sf/mjgxJDp/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/P4RfGhRQSkaKWEmdBi1gaw Scastie (remote JVM)]. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="scala">import java.util.Base64 |
||
object Base64Decode extends App { |
object Base64Decode extends App { |
||
Line 1,476: | Line 1,476: | ||
[http://seed7.sourceforge.net/libraries/encoding.htm#fromBase64(in_string) fromBase64]. |
[http://seed7.sourceforge.net/libraries/encoding.htm#fromBase64(in_string) fromBase64]. |
||
<syntaxhighlight lang=seed7>$ include "seed7_05.s7i"; |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
include "gethttp.s7i"; |
include "gethttp.s7i"; |
||
include "encoding.s7i"; |
include "encoding.s7i"; |
||
Line 1,495: | Line 1,495: | ||
=={{header|SenseTalk}}== |
=={{header|SenseTalk}}== |
||
<syntaxhighlight lang=sensetalk> |
<syntaxhighlight lang="sensetalk"> |
||
put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=") |
put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=") |
||
Line 1,502: | Line 1,502: | ||
Output: |
Output: |
||
<syntaxhighlight lang=sensetalk>To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich</syntaxhighlight> |
<syntaxhighlight lang="sensetalk">To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich</syntaxhighlight> |
||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
<syntaxhighlight lang=ruby>var data = <<'EOT' |
<syntaxhighlight lang="ruby">var data = <<'EOT' |
||
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 |
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 |
||
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
||
Line 1,519: | Line 1,519: | ||
=={{header|Smalltalk}}== |
=={{header|Smalltalk}}== |
||
{{works with|Smalltalk/X}} |
{{works with|Smalltalk/X}} |
||
<syntaxhighlight lang=smalltalk>data := ' |
<syntaxhighlight lang="smalltalk">data := ' |
||
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 |
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2 |
||
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
||
Line 1,530: | Line 1,530: | ||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="standard ml">val debase64 = fn input => |
||
let |
let |
||
Line 1,569: | Line 1,569: | ||
-- Paul R. Ehrlich </pre> |
-- Paul R. Ehrlich </pre> |
||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
<syntaxhighlight lang=tcl>package require tcl 8.6 |
<syntaxhighlight lang="tcl">package require tcl 8.6 |
||
set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= |
||
Line 1,581: | Line 1,581: | ||
=={{header|Visual Basic .NET}}== |
=={{header|Visual Basic .NET}}== |
||
{{trans|D}} |
{{trans|D}} |
||
<syntaxhighlight lang=vbnet>Module Module1 |
<syntaxhighlight lang="vbnet">Module Module1 |
||
Sub Main() |
Sub Main() |
||
Line 1,600: | Line 1,600: | ||
=={{header|Vlang}}== |
=={{header|Vlang}}== |
||
<syntaxhighlight lang=vlang>import encoding.base64 |
<syntaxhighlight lang="vlang">import encoding.base64 |
||
fn main() { |
fn main() { |
||
Line 1,624: | Line 1,624: | ||
{{libheader|Wren-str}} |
{{libheader|Wren-str}} |
||
From first principles using string manipulation. Quick enough here. |
From first principles using string manipulation. Quick enough here. |
||
<syntaxhighlight lang=ecmascript>import "io" for Stdout |
<syntaxhighlight lang="ecmascript">import "io" for Stdout |
||
import "/fmt" for Conv, Fmt |
import "/fmt" for Conv, Fmt |
||
import "/str" for Str |
import "/str" for Str |
||
Line 1,663: | Line 1,663: | ||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
Using shared libraries for cURL and message hashing: |
Using shared libraries for cURL and message hashing: |
||
<syntaxhighlight lang=zkl>var [const] MsgHash=Import("zklMsgHash"), Curl=Import("zklCurl"); |
<syntaxhighlight lang="zkl">var [const] MsgHash=Import("zklMsgHash"), Curl=Import("zklCurl"); |
||
icon:=Curl().get("http://rosettacode.org/favicon.ico"); //-->(Data(4,331),693,0) |
icon:=Curl().get("http://rosettacode.org/favicon.ico"); //-->(Data(4,331),693,0) |
||
Line 1,677: | Line 1,677: | ||
</pre> |
</pre> |
||
{{out|Text based test}} |
{{out|Text based test}} |
||
<syntaxhighlight lang=zkl>msg,b64 := "Rosetta Code Base64 decode data task", MsgHash.base64encode(msg); |
<syntaxhighlight lang="zkl">msg,b64 := "Rosetta Code Base64 decode data task", MsgHash.base64encode(msg); |
||
println("Original: %s\nEncoded: %s\nBytes: %s\nDecoded: %s" |
println("Original: %s\nEncoded: %s\nBytes: %s\nDecoded: %s" |
||
.fmt(msg, b64.text, b64.bytes().apply("toString",16).concat(","), |
.fmt(msg, b64.text, b64.bytes().apply("toString",16).concat(","), |
Revision as of 22:17, 29 August 2022
You are encouraged to solve this task according to the task description, using any language you may know.
See Base64 encode data.
Now write a program that takes the output of the Base64 encode data task as input and regenerate the original file.
When working on the VBA implementation I found several 'solutions' on the net, including one from the software maker himself, that showed output with incorrect padding. Obviously with incorrect padding in the output you can not decode correctly to the original file again.
Action!
BYTE FUNC FindIndex(BYTE b)
IF b>='A AND b<='Z THEN
RETURN (b-'A)
ELSEIF b>='a AND b<='z THEN
RETURN (b-'a+26)
ELSEIF b>='0 AND b<='9 THEN
RETURN (b-'0+52)
ELSEIF b='+ THEN
RETURN (62)
ELSEIF b='/ THEN
RETURN (63)
FI
RETURN (-1)
PROC PrintChar(CHAR c)
IF c=10 THEN
PutE()
ELSE
Put(c)
FI
RETURN
PROC Decode(CHAR ARRAY s)
BYTE i,b1,b2,b3,b4,i1,i2,i3,i4
CHAR c
IF s(0) MOD 4#0 THEN
PrintE("Invalid length of string!!!")
Break()
FI
i=1
WHILE i<=s(0)
DO
b1=s(i) i==+1
b2=s(i) i==+1
b3=s(i) i==+1
b4=s(i) i==+1
i1=FindIndex(b1)
i2=FindIndex(b2)
c=i1 LSH 2
c==%i2 RSH 4
PrintChar(c)
IF b3#'= THEN
i3=FindIndex(b3)
c=(i2&$0F) LSH 4
c==%i3 RSH 2
PrintChar(c)
IF b4#'= THEN
i4=FindIndex(b4)
c=(i3&$03) LSH 6
c==%i4
PrintChar(c)
FI
FI
OD
RETURN
PROC Test(CHAR ARRAY s)
PrintE("Encoded:")
PrintE(s)
PutE()
PrintE("Decoded:")
Decode(s)
PutE()
RETURN
PROC Main()
Test("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo")
RETURN
- Output:
Screenshot from Atari 8-bit computer
Encoded: VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo Decoded: To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Ada
with Ada.Text_IO;
with AWS.Translator;
procedure Decode_AWS is
Input : constant String :=
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" &
"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
Result : constant String := AWS.Translator.Base64_Decode (Input);
begin
Ada.Text_IO.Put_Line (Input);
Ada.Text_IO.New_Line;
Ada.Text_IO.Put_Line (Result);
end Decode_AWS;
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Arturo
text: "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
print decode text
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
BaCon
Using the result from the Base64 encode data task as requested, but the result is abbreviated in the code below.
data$ = "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAE.......QAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE="
ico$ = B64DEC$(data$)
BSAVE ico$ TO "favicon.ico" SIZE LEN(ico$)
Bash
#! /bin/bash
declare -a encodeTable=(
# + , - . / 0 1 2 3 4 5 6 7 8 9 :
62 -1 -1 -1 63 52 53 54 55 56 57 58 59 60 61 -1
# ; < = > ? @ A B C D E F G H I J
-1 -1 -1 -1 -1 -1 0 1 2 3 4 5 6 7 8 9
# K L M N O P Q R S T U V W X Y Z
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
# [ \ ] ^ _ ` a b c d e f g h i j
-1 -1 -1 -1 -1 -1 26 27 28 29 30 31 32 33 34 35
# k l m n o p q r s t u v w x y z
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
)
function a2b6()
{
if [ $1 -lt 43 -o $1 -gt 122 ]
then
echo -1
else
echo ${encodeTable[$(($1-43))]}
fi
}
function flush() {
for (( k=2; k>=4-CNT; k-- ))
do
(( b8=BUF>>(k*8)&255 ))
printf -v HEX %x $b8
printf \\x$HEX
done
}
while read INPUT
do
for (( i=0; i<${#INPUT}; i++ ))
do
printf -v NUM %d "'${INPUT:$i:1}"
if (( NUM==61 ))
then
flush
exit 0
else
DEC=$( a2b6 $NUM )
if (( DEC>=0 ))
then
(( BUF|=DEC<<6*(3-CNT) ))
if (( ++CNT==4 ))
then
flush
(( CNT=0, BUF=0 ))
fi
fi
fi
done
done
C
#include <stdio.h>
#include <stdlib.h>
typedef unsigned char ubyte;
const ubyte BASE64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int findIndex(const ubyte val) {
if ('A' <= val && val <= 'Z') {
return val - 'A';
}
if ('a' <= val && val <= 'z') {
return val - 'a' + 26;
}
if ('0' <= val && val <= '9') {
return val - '0' + 52;
}
if (val == '+') {
return 62;
}
if (val == '/') {
return 63;
}
return -1;
}
int decode(const ubyte source[], ubyte sink[]) {
const size_t length = strlen(source);
const ubyte *it = source;
const ubyte *end = source + length;
int acc;
if (length % 4 != 0) {
return 1;
}
while (it != end) {
const ubyte b1 = *it++;
const ubyte b2 = *it++;
const ubyte b3 = *it++; // might be the first padding byte
const ubyte b4 = *it++; // might be the first or second padding byte
const int i1 = findIndex(b1);
const int i2 = findIndex(b2);
acc = i1 << 2; // six bits came from the first byte
acc |= i2 >> 4; // two bits came from the first byte
*sink++ = acc; // output the first byte
if (b3 != '=') {
const int i3 = findIndex(b3);
acc = (i2 & 0xF) << 4; // four bits came from the second byte
acc += i3 >> 2; // four bits came from the second byte
*sink++ = acc; // output the second byte
if (b4 != '=') {
const int i4 = findIndex(b4);
acc = (i3 & 0x3) << 6; // two bits came from the third byte
acc |= i4; // six bits came from the third byte
*sink++ = acc; // output the third byte
}
}
}
*sink = '\0'; // add the sigil for end of string
return 0;
}
int main() {
ubyte data[] = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
ubyte decoded[1024];
printf("%s\n\n", data);
decode(data, decoded);
printf("%s\n\n", decoded);
return 0;
}
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
C#
using System;
using System.Text;
namespace Base64DecodeData {
class Program {
static void Main(string[] args) {
var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
Console.WriteLine(data);
Console.WriteLine();
var decoded = Encoding.ASCII.GetString(Convert.FromBase64String(data));
Console.WriteLine(decoded);
}
}
}
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
C++
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef unsigned char ubyte;
const auto BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
std::vector<ubyte> encode(const std::vector<ubyte>& source) {
auto it = source.cbegin();
auto end = source.cend();
std::vector<ubyte> sink;
while (it != end) {
auto b1 = *it++;
int acc;
sink.push_back(BASE64[b1 >> 2]); // first output (first six bits from b1)
acc = (b1 & 0x3) << 4; // last two bits from b1
if (it != end) {
auto b2 = *it++;
acc |= (b2 >> 4); // first four bits from b2
sink.push_back(BASE64[acc]); // second output
acc = (b2 & 0xF) << 2; // last four bits from b2
if (it != end) {
auto b3 = *it++;
acc |= (b3 >> 6); // first two bits from b3
sink.push_back(BASE64[acc]); // third output
sink.push_back(BASE64[b3 & 0x3F]); // fouth output (final six bits from b3)
} else {
sink.push_back(BASE64[acc]); // third output
sink.push_back('='); // fourth output (1 byte padding)
}
} else {
sink.push_back(BASE64[acc]); // second output
sink.push_back('='); // third output (first padding byte)
sink.push_back('='); // fourth output (second padding byte)
}
}
return sink;
}
int findIndex(ubyte val) {
if ('A' <= val && val <= 'Z') {
return val - 'A';
}
if ('a' <= val && val <= 'z') {
return val - 'a' + 26;
}
if ('0' <= val && val <= '9') {
return val - '0' + 52;
}
if ('+' == val) {
return 62;
}
if ('/' == val) {
return 63;
}
return -1;
}
std::vector<ubyte> decode(const std::vector<ubyte>& source) {
if (source.size() % 4 != 0) {
throw new std::runtime_error("Error in size to the decode method");
}
auto it = source.cbegin();
auto end = source.cend();
std::vector<ubyte> sink;
while (it != end) {
auto b1 = *it++;
auto b2 = *it++;
auto b3 = *it++; // might be first padding byte
auto b4 = *it++; // might be first or second padding byte
auto i1 = findIndex(b1);
auto i2 = findIndex(b2);
auto acc = i1 << 2; // six bits came from the first byte
acc |= i2 >> 4; // two bits came from the first byte
sink.push_back(acc); // output the first byte
if (b3 != '=') {
auto i3 = findIndex(b3);
acc = (i2 & 0xF) << 4; // four bits came from the second byte
acc |= i3 >> 2; // four bits came from the second byte
sink.push_back(acc); // output the second byte
if (b4 != '=') {
auto i4 = findIndex(b4);
acc = (i3 & 0x3) << 6; // two bits came from the third byte
acc |= i4; // six bits came from the third byte
sink.push_back(acc); // output the third byte
}
}
}
return sink;
}
int main() {
using namespace std;
string data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
vector<ubyte> datav{ begin(data), end(data) };
cout << data << "\n\n" << decode(datav).data() << endl;
return 0;
}
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Caché ObjectScript
USER>Write $System.Encryption.Base64Decode("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=") To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Clojure
(defn decode [str]
(String. (.decode (java.util.Base64/getDecoder) str)))
(decode "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=")
- Output:
"To err is human, but to really foul things up you need a computer.\n -- Paul R. Ehrlich"
Common Lisp
Similar to the BASE64 encoding task I am using the cl-base64 library.
(eval-when (:load-toplevel :compile-toplevel :execute)
(ql:quickload "cl-base64"))
;; * The package definition
(defpackage :base64-decode
(:use :common-lisp :cl-base64))
(in-package :base64-decode)
;; * The encoded data
(defvar *base64-data*
"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"
"See BASE64-ENCODE for the origin of this
data. http://rosettacode.org/wiki/Base64_encode_data")
;; * The function
(defun base64-decode (&optional (data *base64-data*) (file #p"favicon-2.ico"))
"Returns the original FILE BASE64 encoded in DATA."
(with-open-file (stream file :direction :output :element-type 'unsigned-byte
:if-exists :supersede :if-does-not-exist :create)
(let* ((array (base64-string-to-usb8-array data))
(len (length array)))
(write-sequence array stream)
(format t "Wrote ~D bytes in file ~A~%" len file))))
- Output:
Wrote 3638 bytes in file favicon-2.ico
Crystal
require "base64"
encoded_string = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
decoded_string = Base64.decode_string(encoded_string)
puts decoded_string
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
D
import std.base64;
import std.stdio;
void main() {
auto data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
writeln(data);
writeln;
auto decoded = cast(char[])Base64.decode(data);
writeln(decoded);
}
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Dart
import 'dart:convert';
void main() {
var encoded = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
var decoded = utf8.decode(base64.decode(encoded));
print(decoded);
}
- Output:
To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Delphi
program Base64Decoder;
{$APPTYPE CONSOLE}
uses
System.SysUtils, System.NetEncoding;
const
Src = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';
begin
WriteLn(Format('Source string: ' + sLineBreak + '"%s"', [Src]));
WriteLn(Format('Decoded string: ' + sLineBreak + '"%s"', [TNetEncoding.Base64.Decode(Src)]));
end.
- Output:
Source string: "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=" Decoded string: "To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich"
F#
Standard Library
open System
open System.IO
let encoded = "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"
let decoded = Convert.FromBase64String encoded
File.WriteAllBytes("favicon.ico", decoded)
- Output:
Manual Implementation
open System
open System.IO
let encoded = "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAEABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///wCGiYcARkhHAL/CwAAmKScAam1rAOPm5ACgo6EAV1pYABcZGADO0c8AODs5AK2wrgBzdnQA6+7sAPz//QAAAwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBAYMBQUMBgQQEBAQEBAQBhEJDQsLDQkFBxAQEBAQBBEJEBAQEBAQEBAQEBAQEA0RDhAQEBAQEBAQEBAQEBAPCgoLEBAQEAkMDxAQEBAQEAsMEQwJAwoREQ8QERAQEAIGEAcNCAgLCwsQEBEQEA0DEBAQEBAQEBAQEBARDwQMBxAQEBAQEBAQEBAQEQMMAw8QEBAQEBAQEBAQEBEQEAgJEBAQEBAQEBAQEBAREBAEDBAQEBAQEBAQEBAQEQ4GBQgQEBAQEBAQEBAQEAQEBA8QEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAACAAAABAAAAAAQAIAAAAAACABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8AfoJ/AD9BQAC+wb8A3uHfAB8iIACeoZ8AXmFfAA4SEADO0c8ArrKvAG5xbwDu8e8AT1FPAI6RkAAuMS8A5unnABcaGADW2dcANjk3AMbJxwC2ubcAZmlnAHZ5dwD2+fcApqmoAJaamACGiYcABgkHAEZJRwBWWFcAKCspAIuNjACUlJQA8vXzAOrt6wAkJyUA4uXjANrd2wAyNTMA0tXTADo9OwDKzcsAwsXDALq9uwBiZWMAam1rAKKlowBydXMACwsLAPr9+wBKTkwAGx0cAFJVUwBbXVsAgoWDAEJFQwCqrKsAmpubACsuLACztrQAe398AAsPDABYW1kAiIyJAN3e3QDBwsEASUtKALm6uQCRk5IA+fn5AO3t7QAEBwUACAsJAPz//QD09/UA8PPxACEkIgDo6+kA5OflAODk4QAwMzEA2NvZADw/PQDQ09EAREdFAMzPzQCxtLIAYGNhAGRnZQBoa2kApKelAKCjoQB0d3UAnJ+dAISHhQCMj40Afn9+AMTGxQBNUE4AUFNRALzAvQBcX10AbHBtAICDgQCYmpkADxAPAPz8/AD4/PoA9vb2AB4gHwDy8vIA8PDwADU3NgBAQ0EAv8PAAKiqqQBvc3AAcXRyAJWYlgAGBwYA7e/uAOjp6ADIycgAXl9eAKaopgCUlpUA/f//AObn5wA8PT0A0NHRABYZFwD+/v4A+/78APv7+wAgIyEA+fv5ACIlIwD3+vgA+Pj4APf39wD1+PYAKi0rAPP29AAsLy0A8/PzAPH08gDp7OoANzo4AOXo5gA7PjwA4+bkAN/i4ABDRkQA3eDeAEVIRgDb3twAR0pIANXZ1gDT1tQAUVRSAMvOzABXWlgAyczKAFlcWgDFyMYAX2JgAMHEwgBhZGIAY2ZkAGVoZgC7vrwAZ2poALm8ugBpbGoAa25sALW4tgC0t7UAdXh2AHd6eACjpqQAoaSiAIGEggCDhoQAnaCeAIWIhgCbnpwAh4qIAJmcmgCKjYsAi46MAI2QjgCSlJMAkJSRAAoLCgAKDAsAGBoZAP3+/QD8/f0A7/HwADEzMgDv8O8A7O/tAOzt7ADn6ugA3+DfANzf3QBIS0kA2dvaAExPTQBPUlAAW15cAMDDwQC9wL4AuLu5AHx/fQCnqqgAfYB+AImMigCPkpAAk5aUAA8QEAAPEhAAHiEfACEjIQD+//8A/v/+AP3//gD9/v4A/P79APv//AD7/v0A/P78APv9/AD7/PwA+/37AC4wLwD5/PoA+fv6APj7+QD4+fkA+Pn4APb69wD3+fcA9/j3APb49wDy9PMA8fPyAO/z8QDw8vEA8PHwAERGRQDu8u8A7/HvAEVHRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIaFhenp6enphobmhYWF5osjeiRPzXvNTyR6I4uFhcYAgAEBAQEBAQEBAQEBAQEBzaKyfrsbeBu7fj0rlgEBAQCGAQEBAQEBAQEBAQHuUS14GKeh0FaaVtChCLPd1fP0AIYBAUtLS0tL4wEBgS24ozkeodSqq62rqtTTnJqvZpgAhgEBS0tLS0sBhfeuDJGEj2ccXK4sFSyuXGAIlw620QCGAQFLS0vk5OLyn7hSHeDUtnzODUyLTA2bptm+RkOWAIYBAUtLS+IB5A0Wo98/odmUR8dL5OLkSzPwjpOSjIkAhgEBS0tL4gHoljBzSRJ3VwEBAQEBAQEBAQEBAQEBhQCGAQFLS0viAYaW2R5Kxa/VhgEBAQEBAQEB4vBM8WzsAIYBAUtLS+TixvrWpcR5/7Z6AQEBAQEBAQEmPRsaKcsA5gEBAeRLS+QB45lB7TIGF7JRevvIDcpImbY3UjS1mwDlAQEB4ktLSwEBSysCgoRO0l4PB7UwOyFeOd4ACWATAO5ucSMzS0vkAYX2UbHYVuHgEERnqi4f/Mlva8OI3CcA/QTdWE3k5AEBlKQLtl29YqpA1C6rLghnZ31nfXZ0TwBQvJUxEQEBASPVIXa6183MoK7ZB1+9BwvWY6h0VyMZAFFeEmdQAQHyn8Bnr3VCAQEBk1EToClTlpDw80zqAeYAJj4lF08BhdF+L1lqUIcBAQHkM/Dwi+6G5OLi4gEB5gCYAo9oJAF7fjFbRoMBAQFL4gEBAQEBAQEBAQEBAQHpAFC3INQVmFhbZAJV6wEB5Evk5OLi4uLi4uTk5OQBAekAEUGKyRi/qhQDwU0BAeRLS0tLS0tLS0tLS0tLSwEB6QDNYQY1DmdkVKF/nWyF5EtLS0tLS0tLS0tLS0tLAQHpABFBinK4IkbYs7d+KfXj5EtLS0tLS0tLS0tLS0sBAekAmGkgLidwkgq5L69+/gEBS0tLS0tLS0tLS0tLSwEB6QAm2jyzAQEBhqxanr8kAQFLS0tLS0tLS0tLS0tLAQHpAJjaJS4FR43P2VkORssBAUtLS0tLS0tLS0tLS0sBAekAUNiEKrlFOkGrZbALIwEBS0tLS0tLS0tLS0tLSwEB6QBPwjwoMduzNh6puZ/wAeJLS0tLS0tLS0tLS0tLAQHpAPl0d6u3wDi0t36g+Evk5EtLS0tLS0tLS0tLS0sBAekAi0ykLQR0LAomkOIBAQEBAQEBAQEBAQEBAQEBAQEB6QDkAQHkbRnnAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAOaFhYbu7zPmhYWF5oaGhoaGhoaGhoaGhoaGhoaFhekA/////wAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE="
let decode (s: string) =
let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".ToCharArray()
let filtered = String.filter (fun c -> Array.contains c chars || c = '=') s
let paddingSize = filtered |> String.filter ((=) '=') |> String.length
let s = filtered.Replace('=', 'A').ToCharArray() |> Array.map int
let ints = chars |> Array.map int
let calc c =
let n = [c..(c + 3)]
|> List.sumBy (fun k -> Array.IndexOf(ints, s.[k]) <<< (18 - 6 * (k % 4)))
[16; 8; 0]
|> List.map (fun k -> (n >>> k) &&& 255 |> char |> string) |> List.reduce (+)
[0..4..Array.length s - 1]
|> List.map calc
|> List.reduce (+)
|> fun r -> r.Substring(0, String.length r - paddingSize).ToCharArray()
|> Array.map byte
let decoded = decode encoded
File.WriteAllBytes("favicon.ico", decoded)
- Output:
Factor
USING: base64 io strings ;
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"
base64> >string print
- Output:
To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Forth
Inspired from Wikipedia. Use of a buffer. May be also of interest : github.com/lietho/base64-forth
variable bitsbuff
: char>6bits ( c -- u )
dup 43 = if drop 62 exit then ( + case )
dup 47 = if drop 63 exit then ( / case )
dup 48 58 within if 48 - 52 + exit then ( 0-9 case )
dup 65 91 within if 65 - exit then ( A-Z case )
dup 97 123 within if 97 - 26 + exit then ( a-z case )
drop 0 ( padding )
;
: 6bitsin ( v -- ) bitsbuff @ 6 lshift + bitsbuff ! ;
: 4charsin ( addr -- addr+4 )
$0 bitsbuff !
dup 4 + dup rot
do I c@ char>6bits 6bitsin loop ;
: 3bytes, ( -- )
bitsbuff @ 16 rshift $ff and c,
bitsbuff @ 8 rshift $ff and c,
bitsbuff @ $ff and c, ;
: b64dec ( addr1 n1 -- addr2 n2 )
here rot rot ( addr2 addr1 n1 )
4 / ( addr2 addr1 n1/4 )
0 do
4charsin 3bytes,
loop ( addr2 addr1+4x )
( get back for padding )
1 - dup c@ 61 = if 1 else 0 then swap ( addr2 0|1 addr1+4x-1 )
1 - c@ 61 = if 1 else 0 then + ( addr2 0|1|2 )
swap ( 0|1|2 addr2 )
dup here swap - ( 0|1|2 addr2 n' )
rot - ( addr2 n2 )
;
- Output:
s" VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" b64dec cr type cr To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich ok ( encode with b64enc as coded for Base64 encode data task ) s" VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" b64dec b64enc cr type VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo ok s" YW55IGNhcm5hbCBwbGVhc3VyZS4=" b64dec cr type cr any carnal pleasure. ok s" YW55IGNhcm5hbCBwbGVhc3VyZQ==" b64dec cr type cr any carnal pleasure ok
FreeBASIC
Dim Shared As String B64
B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _
"abcdefghijklmnopqrstuvwxyz" & _
"0123456789+/"
Function MIMEDecode(s As String ) As Integer
If Len(s) Then
MIMEdecode = Instr(B64,s) - 1
Else
MIMEdecode = -1
End If
End Function
Function Decode64(s As String) As String
Dim As Integer w1, w2, w3, w4
Dim As String mD
For n As Integer = 1 To Len(s) Step 4
w1 = MIMEdecode(Mid(s,n+0,1))
w2 = MIMEdecode(Mid(s,n+1,1))
w3 = MIMEdecode(Mid(s,n+2,1))
w4 = MIMEdecode(Mid(s,n+3,1))
If w2 >-1 Then mD+= Chr(((w1* 4 + Int(w2/16)) And 255))
If w3 >-1 Then mD+= Chr(((w2*16 + Int(w3/ 4)) And 255))
If w4 >-1 Then mD+= Chr(((w3*64 + w4 ) And 255))
Next n
Return mD
End Function
Dim As String msg64 = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" & _
"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
Print msg64
Print: Print(Decode64(msg64))
Sleep
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Go
As images can no longer be uploaded to RC, I've encoded and decoded a string rather than the Rosetta Code icon.
package main
import (
"encoding/base64"
"fmt"
)
func main() {
msg := "Rosetta Code Base64 decode data task"
fmt.Println("Original :", msg)
encoded := base64.StdEncoding.EncodeToString([]byte(msg))
fmt.Println("\nEncoded :", encoded)
decoded, err := base64.StdEncoding.DecodeString(encoded)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("\nDecoded :", string(decoded))
}
- Output:
Original : Rosetta Code Base64 decode data task Encoded : Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr Decoded : Rosetta Code Base64 decode data task
Groovy
import java.nio.charset.StandardCharsets
class Decode {
static void main(String[] args) {
String data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
Base64.Decoder decoder = Base64.getDecoder()
byte[] decoded = decoder.decode(data)
String decodedStr = new String(decoded, StandardCharsets.UTF_8)
System.out.println(decodedStr)
}
}
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Haskell
Simple implementation that decodes an ASCII string.
--Decodes Base64 to ASCII
import qualified Data.Map.Strict as Map (Map, lookup, fromList)
import Data.Maybe (fromJust, listToMaybe, mapMaybe)
import Numeric (readInt, showIntAtBase)
import Data.Char (chr, digitToInt)
import Data.List.Split (chunksOf)
byteToASCII :: String -> String
byteToASCII = map chr . decoder
--generates list of bytes (represented by Int)
decoder :: String -> [Int]
decoder =
map readBin .
takeWhile (\x -> length x == 8) .
chunksOf 8 . concatMap toBin . mapMaybe (`Map.lookup` table) . filter (/= '=')
--turns decimal into a list of char that represents a binary number
toBin :: Int -> String
toBin n = leftPad $ showIntAtBase 2 ("01" !!) n ""
--this adds all the zeros to the left that showIntAtBase omitted
leftPad :: String -> String
leftPad a = replicate (6 - length a) '0' ++ a
--turns list of '0' and '1' into list of 0 and 1
readBin :: String -> Int
readBin = fromJust . fmap fst . listToMaybe . readInt 2 (`elem` "01") digitToInt
--lookup list for the sextets
table :: Map.Map Char Int
table =
Map.fromList $
zip "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" [0 ..]
main :: IO ()
main =
putStrLn $
byteToASCII
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA=="
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
or in terms of Data.ByteString.Base64:
{-# LANGUAGE OverloadedStrings #-}
import qualified Data.ByteString.Base64 as Base64 (decode, encode)
import qualified Data.ByteString.Char8 as B (putStrLn)
main :: IO ()
main = do
B.putStrLn $
Base64.encode
"To err is human, but to really foul things up you need a computer.\n-- Paul R. Ehrlich"
B.putStrLn "\n-->\n"
either print B.putStrLn $
Base64.decode
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA=="
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA== --> To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Haxe
class Main {
static function main() {
var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" +
"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
Sys.println('$data\n');
var decoded = haxe.crypto.Base64.decode(data);
Sys.println(decoded);
}
}
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
J
using J's convert/misc/base64 script:
require'convert/misc/base64'
frombase64 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='
To err is human, but to really foul things up you need a computer.
-- Paul R. Ehrlich
Alternative implementation based on that script:
BASE64=: (a.{~ ,(a.i.'Aa') +/i.26),'0123456789+/'
frombase64=: {{
pad=. _2 >. (y i. '=') - #y
pad }. a. {~ #. _8 [\ , (6#2) #: BASE64 i. y
}}
Java
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class Decode {
public static void main(String[] args) {
String data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
Base64.Decoder decoder = Base64.getDecoder();
byte[] decoded = decoder.decode(data);
String decodedStr = new String(decoded, StandardCharsets.UTF_8);
System.out.println(decodedStr);
}
}
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
JavaScript
Browser
// define base64 data; in this case the data is the string: "Hello, world!"
const base64 = 'SGVsbG8sIHdvcmxkIQ==';
// atob is a built-in function.
console.log(atob(base64));
Node.js
// define base64 data; in this case the data is the string: "Hello, world!"
const base64 = Buffer.from('SGVsbG8sIHdvcmxkIQ==', 'base64');
// <Buffer>.toString() is a built-in method.
console.log(base64.toString());
- Output:
Hello, world!
jq
Simply pipe the base64 string into:
jq -rR base64d
Jsish
See Base64_encode_data#Jsish for base64.jsi.
/* Base64 decode, in Jsish */
var data = exec('jsish base64.jsi', {retAll:true}).data; // or use File.read('stdin');
var icon = Util.base64(data, true);
File.write('rosetta-favicon.ico', icon);
Julia
Using an IOBuffer here, though not really needed to decode a string, shows how we could pipe a network stream or file though Julia's builtin Base64 decoder.
using Base64
io = IOBuffer()
iob64_decode = Base64DecodePipe(io)
write(io, "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo")
seekstart(io)
println(String(read(iob64_decode)))
- Output:
To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Kotlin
import java.util.Base64
fun main() {
val data =
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
val decoder = Base64.getDecoder()
val decoded = decoder.decode(data)
val decodedStr = String(decoded, Charsets.UTF_8)
println(decodedStr)
}
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Lua
-- Start taken from https://stackoverflow.com/a/35303321
local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' -- You will need this for encoding/decoding
-- decoding
function dec(data)
data = string.gsub(data, '[^'..b..'=]', '')
return (data:gsub('.', function(x)
if (x == '=') then return '' end
local r,f='',(b:find(x)-1)
for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
return r;
end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
if (#x ~= 8) then return '' end
local c=0
for i=1,8 do c=c+(x:sub(i,i)=='1' and 2^(8-i) or 0) end
return string.char(c)
end))
end
-- end of copy
local data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"
print(data)
print()
local decoded = dec(data)
print(decoded)
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Mathematica/Wolfram Language
ImportString[
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo",
"Base64"
]
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Nim
import base64
const Source = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
echo Source.decode()
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
OCaml
We continue from the same toplevel session from the previous page:
# let plain = Base64.decode_exn enc;; val plain : string = "\000\000\001\000\002\000\016\016\000\000\000\000\000\000h\005\000\000&\000"... (* string length 3638; truncated *)
Ol
(define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
(define kernel (alist->ff (map cons (string->bytes base64-codes) (iota (string-length base64-codes)))))
; returns n bits from input binary stream
(define (bits n hold)
(let loop ((hold hold))
(vector-apply hold (lambda (v i l)
(cond
((null? l)
(values (>> v (- i n)) #false))
((pair? l)
(if (not (less? i n))
(values (>> v (- i n)) (vector (band v (- (<< 1 (- i n)) 1)) (- i n) l))
(loop (vector
(bor (<< v 6) (kernel (car l) 0))
(+ i 6)
(unless (eq? (car l) "=") (cdr l))))))
(else
(loop (vector v i (l)))))))))
; decoder.
(define (decode str)
(print "decoding string '" str "':")
(let loop ((hold [0 0 (str-iter str)]))
(let*((bit hold (bits 8 hold)))
(unless (zero? bit) (display (string bit)))
(when hold
(loop hold))))
(print)(print))
; TESTING
(decode "SGVsbG8sIExpc3Ah")
(decode "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=")
(decode "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=")
- Output:
Hello, Lisp! To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.
Perl
The MIME::Base64 module is to be preferred, but this works too.
sub decode_base64 {
my($d) = @_;
$d =~ tr!A-Za-z0-9+/!!cd;
$d =~ s/=+$//;
$d =~ tr!A-Za-z0-9+/! -_!;
my $r = '';
while( $d =~ /(.{1,60})/gs ){
my $len = chr(32 + length($1)*3/4);
$r .= unpack("u", $len . $1 );
}
$r;
}
$data = <<EOD;
J1R3YXMgYnJpbGxpZywgYW5kIHRoZSBzbGl0aHkgdG92ZXMKRGlkIGd5cmUgYW5kIGdpbWJsZSBp
biB0aGUgd2FiZToKQWxsIG1pbXN5IHdlcmUgdGhlIGJvcm9nb3ZlcywKQW5kIHRoZSBtb21lIHJh
dGhzIG91dGdyYWJlLgo=
EOD
print decode_base64($data) . "\n";
- Output:
'Twas brillig, and the slithy toves Did gyre and gimble in the wabe: All mimsy were the borogoves, And the mome raths outgrabe.
Phix
with javascript_semantics include builtins\base64.e string s = "Rosetta Code Base64 decode data task" string e = encode_base64(s) ?e ?decode_base64(e)
- Output:
"Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr" "Rosetta Code Base64 decode data task"
PHP
$encoded = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw' .
'IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';
echo
$encoded, PHP_EOL,
base64_decode($encoded), PHP_EOL;
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
PicoLisp
(setq *Char64
`'(chop
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) )
(de decode64 (S)
(let S (chop S)
(pack
(make
(while S
(let
(A (dec (index (++ S) *Char64))
B (dec (index (++ S) *Char64))
C (dec (index (++ S) *Char64))
D (dec (index (++ S) *Char64)) )
(link
(char (| (>> -2 A) (>> 4 B))) )
(and
C
(link
(char
(| (>> -4 (& B 15)) (>> 2 C)) ) )
D
(link
(char (| (>> -6 (& C 3)) D)) ) ) ) ) ) ) ) )
(prinl (decode64 "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"))
- Output:
To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Pike
By necessity this also implements all of the Base64 encode task to avoid a humongous amount of icon data hardcoded in the program.
string icon = Protocols.HTTP.get_url_data("http://rosettacode.org/favicon.ico");
string encoded = MIME.encode_base64(icon);
Stdio.write_file("favicon.ico", MIME.decode_base64(encoded));
Prolog
In SWI-Prolog base64 is a built in predicate. https://www.swi-prolog.org/pldoc/doc_for?object=base64%3Abase64/2
This predicate is reversable and can encode or decode.
- Output:
?- Encoded = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=', base64(Plain, Encoded). Plain = 'To err is human, but to really foul things up you need a computer.\n -- Paul R. Ehrlich'.
PureBasic
b64cd$ = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" +
"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
*p_buf = AllocateMemory(1024)
Base64Decoder(b64cd$, *p_buf, 1024)
OpenConsole("") : PrintN(PeekS(*p_buf, -1, #PB_UTF8))
Input()
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Python
import base64
data = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='
print(base64.b64decode(data).decode('utf-8'))
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
QB64
Option _Explicit
Dim As String udata, decoded
udata = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"
decoded = decode(udata)
Print udata
Print decoded
Function findIndex& (value As _Unsigned _Byte)
If Asc("A") <= value And value <= Asc("Z") Then
findIndex = value - Asc("A")
Exit Function
End If
If Asc("a") <= value And value <= Asc("z") Then
findIndex = value - Asc("a") + 26
Exit Function
End If
If Asc("0") <= value And value <= Asc("9") Then
findIndex = value - Asc("0") + 52
Exit Function
End If
If value = Asc("+") Then
findIndex = 62
Exit Function
End If
If value = Asc("/") Then
findIndex = 63
Exit Function
End If
findIndex = -1
End Function
Function encode$ (source As String)
Dim As String Base64: Base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
Dim As _Unsigned _Integer64 length: length = Len(source)
Dim As _Unsigned _Integer64 it, strend
Dim As Long acc
Dim As String sink
strend = length
While it <> strend
Dim As _Unsigned _Byte b1, b2, b3, b4
it = it + 1
b1 = Asc(Mid$(source, it, 1))
sink = sink + Mid$(Base64, _SHR(b1, 2), 1)
acc = _SHL(b1 And &H3, 4)
If it <> strend Then
it = it + 1
b2 = Asc(Mid$(source, it, 1))
acc = acc Or _SHR(b2, 4)
sink = sink + Mid$(Base64, acc, 1)
acc = _SHL(b2 And &HF, 2)
If it <> strend Then
it = it + 1
b3 = Asc(Mid$(source, it, 1))
acc = acc Or _SHR(b3, 6)
sink = sink + Mid$(Base64, acc, 1)
sink = sink + Mid$(Base64, b3 And &H3F, 1)
Else
sink = sink + Mid$(Base64, acc, 1)
sink = sink + "="
End If
Else
sink = sink + Mid$(Base64, acc, 1)
sink = sink + "="
sink = sink + "="
End If
Wend
encode = sink
End Function
Function decode$ (source As String)
Dim As _Unsigned _Integer64 length: length = Len(source)
Dim As _Unsigned _Integer64 it, strend
Dim As Long acc
Dim As String sink
strend = length
While it <> strend
Dim As _Unsigned _Byte b1, b2, b3, b4
it = it + 1
b1 = Asc(Mid$(source, it, 1))
it = it + 1
b2 = Asc(Mid$(source, it, 1))
it = it + 1
b3 = Asc(Mid$(source, it, 1))
it = it + 1
b4 = Asc(Mid$(source, it, 1))
Dim As Long i1, i2
i1 = findIndex(b1)
i2 = findIndex(b2)
acc = _SHL(i1, 2)
acc = acc Or _SHR(i2, 4)
sink = sink + Chr$(acc)
If b3 <> Asc("=") Then
Dim As Long i3
i3 = findIndex(b3)
acc = _SHL(i2 And &HF, 4)
acc = acc Or _SHR(i3, 2)
sink = sink + Chr$(acc)
If b4 <> Asc("=") Then
Dim As Long i4
i4 = findIndex(b4)
acc = _SHL(i3 And &H3, 6)
acc = acc Or i4
sink = sink + Chr$(acc)
End If
End If
Wend
decode = sink
End Function
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
R
Using base64enc
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |>
base64enc::base64decode() |>
rawToChar() |>
cat()
- Output:
To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Raku
(formerly Perl 6)
my $e64 = '
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
';
my @base64map = flat 'A' .. 'Z', 'a' .. 'z', ^10, '+', '/';
my %base64 is default(0) = @base64map.pairs.invert;
sub base64-decode-slow ($enc) {
my $buf = Buf.new;
for $enc.subst(/\s/, '', :g).comb(4) -> $chunck {
$buf.append: |(sprintf "%06d%06d%06d%06d", |$chunck.comb.map:
{%base64{$_}.base(2)}).comb(8).map: {:2($_)};
}
$buf
}
say 'Slow:';
say base64-decode-slow($e64).decode('utf8');
# Of course, the above routine is slow and is only for demonstration purposes.
# For real code you should use a module, which is MUCH faster and heavily tested.
say "\nFast:";
use Base64::Native;
say base64-decode($e64).decode('utf8');
- Output:
Slow: To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich Fast: To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Red
Red [Source: https://github.com/vazub/rosetta-red]
print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Ring
#======================================#
# Sample: Base64 decode data
# Author: Gal Zsolt, Mansour Ayouni
#======================================#
load "guilib.ring"
oQByteArray = new QByteArray()
oQByteArray.append("Rosetta Code Base64 decode data task")
oba = oQByteArray.toBase64().data()
see oba + nl
oQByteArray = new QByteArray()
oQByteArray.append(oba)
see oQByteArray.fromBase64(oQByteArray).data()
- Output:
Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr Rosetta Code Base64 decode data task
Ruby
require 'base64'
raku_example ='
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
'
puts Base64.decode64 raku_example
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Rust
use std::str;
const INPUT: &str = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
const UPPERCASE_OFFSET: i8 = -65;
const LOWERCASE_OFFSET: i8 = 26 - 97;
const NUM_OFFSET: i8 = 52 - 48;
fn main() {
println!("Input: {}", INPUT);
let result = INPUT.chars()
.filter(|&ch| ch != '=') //Filter '=' chars
.map(|ch| { //Map char values using Base64 Characters Table
let ascii = ch as i8;
let convert = match ch {
'0' ... '9' => ascii + NUM_OFFSET,
'a' ... 'z' => ascii + LOWERCASE_OFFSET,
'A' ... 'Z' => ascii + UPPERCASE_OFFSET,
'+' => 62,
'/' => 63,
_ => panic!("Not a valid base64 encoded string")
};
format!("{:#08b}", convert)[2..].to_string() //convert indices to binary format and remove the two first digits
})
.collect::<String>() //concatenate the resulting binary values
.chars()
.collect::<Vec<char>>()
.chunks(8) //split into 8 character chunks
.map(|chunk| {
let num_str = chunk.iter().collect::<String>();
usize::from_str_radix(&num_str, 2).unwrap() as u8 //convert the binary string into its u8 value
})
.collect::<Vec<_>>();
let result = str::from_utf8(&result).unwrap(); //convert into UTF-8 string
println!("Output: {}", result);
}
- Output:
Input: VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo Output: To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Scala
- Output:
Best seen in running your browser either by ScalaFiddle (ES aka JavaScript, non JVM) or Scastie (remote JVM).
import java.util.Base64
object Base64Decode extends App {
def text2BinaryDecoding(encoded: String): String = {
val decoded = Base64.getDecoder.decode(encoded)
new String(decoded, "UTF-8")
}
def data =
"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
println(text2BinaryDecoding(data))
}
Seed7
The Seed7 library encoding.s7i defines the functions toBase64 and fromBase64.
$ include "seed7_05.s7i";
include "gethttp.s7i";
include "encoding.s7i";
const proc: main is func
local
var string: original is "";
var string: encoded is "";
begin
original := getHttp("rosettacode.org/favicon.ico");
encoded := toBase64(original);
writeln("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: " <&
fromBase64(encoded) = original);
end func;
- Output:
Is the Rosetta Code icon the same (byte for byte) encoded then decoded: TRUE
SenseTalk
put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=")
Output:
To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich
Sidef
var data = <<'EOT'
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
EOT
say data.decode_base64
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Smalltalk
data := '
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
'.
data base64Decoded asString printCR.
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Standard ML
val debase64 = fn input =>
let
infix 2 Worb
infix 2 Wandb
fun (p Worb q ) = Word.orb (p,q);
fun (p Wandb q ) = Word.andb (p,q);
fun decode #"/" = 0wx3F
| decode #"+" = 0wx3E
| decode c = if Char.isDigit c then Word.fromInt (ord c) + 0wx04
else if Char.isLower c then Word.fromInt (ord c) - 0wx047
else if Char.isUpper c then Word.fromInt (ord c) - 0wx041
else 0wx00 ;
fun convert (a::b::c::d::_) =
let
val w = Word.<< (a,0wx12) Worb Word.<< (b,0wx0c) Worb Word.<< (c,0wx06) Worb d
in
[Word.>> (w,0wx10), Word.>> ((w Wandb 0wx00ff00),0wx08) , w Wandb 0wx0000ff ]
end
| convert _ = [] ;
fun decodeLst [] = []
| decodeLst ilist = ( convert o map decode )( List.take (ilist,4) ) @ decodeLst (List.drop (ilist,4))
in
String.implode ( List.map (chr o Word.toInt) ( decodeLst (String.explode input )) )
end handle Subscript => "Invalid code\n" ;
call
val input = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="; print (debase64 input) ; To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Tcl
package require tcl 8.6
set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
puts [binary decode base64 $data]
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Visual Basic .NET
Module Module1
Sub Main()
Dim data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
Console.WriteLine(data)
Console.WriteLine()
Dim decoded = Text.Encoding.ASCII.GetString(Convert.FromBase64String(data))
Console.WriteLine(decoded)
End Sub
End Module
- Output:
VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g= To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
Vlang
import encoding.base64
fn main() {
msg := "Rosetta Code Base64 decode data task"
println("Original : $msg")
encoded := base64.encode_str(msg)
println("\nEncoded : $encoded")
decoded := base64.decode_str(encoded)
println("\nDecoded : $decoded")
}
- Output:
Original : Rosetta Code Base64 decode data task Encoded : Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr Decoded : Rosetta Code Base64 decode data task
Wren
From first principles using string manipulation. Quick enough here.
import "io" for Stdout
import "/fmt" for Conv, Fmt
import "/str" for Str
var alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
var decode = Fn.new { |s|
if (s == "") return s
var d = ""
for (b in s) {
var ix = alpha.indexOf(b)
if (ix >= 0) d = d + Fmt.swrite("$06b", ix)
}
if (s.endsWith("==")) {
d = d[0..-5]
} else if (s.endsWith("=")){
d = d[0..-3]
}
var i = 0
while (i < d.count) {
var ch = String.fromByte(Conv.atoi(d[i..i+7], 2))
System.write(ch)
i = i + 8
}
Stdout.flush()
}
var s = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
for (chunk in Str.chunks(s, 4)) decode.call(chunk)
System.print()
- Output:
To err is human, but to really foul things up you need a computer. -- Paul R. Ehrlich
zkl
Using shared libraries for cURL and message hashing:
var [const] MsgHash=Import("zklMsgHash"), Curl=Import("zklCurl");
icon:=Curl().get("http://rosettacode.org/favicon.ico"); //-->(Data(4,331),693,0)
icon=icon[0][icon[1],*]; // remove header
iconEncoded:=MsgHash.base64encode(icon);
iconDecoded:=MsgHash.base64decode(iconEncoded);
File("rosettaCodeIcon.ico","wb").write(iconDecoded); # eyeball checking says good
println("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: ",
icon==iconDecoded);
- Output:
Is the Rosetta Code icon the same (byte for byte) encoded then decoded: True
- Text based test:
msg,b64 := "Rosetta Code Base64 decode data task", MsgHash.base64encode(msg);
println("Original: %s\nEncoded: %s\nBytes: %s\nDecoded: %s"
.fmt(msg, b64.text, b64.bytes().apply("toString",16).concat(","),
MsgHash.base64decode(b64).text));
Original: Rosetta Code Base64 decode data task Encoded: Um9zZXR0YSBDb2RlIEJhc2U2NCBkZWNvZGUgZGF0YSB0YXNr Bytes: 55,6d,39,7a,5a,58,52,30,59,53,42,44,62,32,52,6c,49,45,4a,68,63,32,55,32,4e,43,42,6b,5a,57,4e,76,5a,47,55,67,5a,47,46,30,59,53,42,30,59,58,4e,72,a Decoded: Rosetta Code Base64 decode data task
- Programming Tasks
- Solutions by Programming Task
- Action!
- Ada
- AWS
- Arturo
- BaCon
- Bash
- C
- C sharp
- C++
- Caché ObjectScript
- Clojure
- Common Lisp
- Crystal
- D
- Dart
- Delphi
- F Sharp
- Factor
- Forth
- FreeBASIC
- Go
- Groovy
- Haskell
- Haxe
- J
- Java
- JavaScript
- Jq
- Jsish
- Julia
- Kotlin
- Lua
- Mathematica
- Wolfram Language
- Nim
- OCaml
- Ol
- Perl
- Phix
- PHP
- PicoLisp
- Pike
- Prolog
- PureBasic
- Python
- QB64
- R
- Base64enc
- Raku
- Red
- Ring
- Ruby
- Rust
- Scala
- Seed7
- SenseTalk
- Sidef
- Smalltalk
- Standard ML
- Tcl
- Visual Basic .NET
- Vlang
- Wren
- Wren-fmt
- Wren-str
- Zkl