Base64 decode data: Difference between revisions

 

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.

 

=={{header|Ada}}==

{{libheader|AWS}}

 

with AWS.Translator;

Ada.Text_IO.New_Line;

Ada.Text_IO.Put_Line (Result);

 

{{out}}

=={{header|Arturo}}==

 

 

 

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich</pre>

 

=={{header|Bash}}==

{{trans|Bash}}

declare -a encodeTable=(

# + , - . / 0 1 2 3 4 5 6 7 8 9 :

fi

done

 

=={{header|C}}==

{{trans|C++}}

#include <stdlib.h>

 

 

return 0;

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo

--Paul R.Ehrlich</pre>

 

{{trans|Visual Basic .NET}}

using System.Text;

 

}

}

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

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

{{Works with|C++14}}

#include <iostream>

#include <string>

 

return 0;

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo

-- Paul R. Ehrlich

</pre>

 

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

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.

 

(ql:quickload "cl-base64"))

 

(len (length array)))

(write-sequence array stream)

{{out}}

 

 

=={{header|Crystal}}==

 

encoded_string = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

 

decoded_string = Base64.decode_string(encoded_string)

 

{{out}}

=={{header|D}}==

{{trans|Raku}}

import std.stdio;

 

auto decoded = cast(char[])Base64.decode(data);

writeln(decoded);

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

end.

{{out}}

<pre>Source string:

-- Paul R. Ehrlich"</pre>

 

===Standard Library===

open System

open System.IO

 

File.WriteAllBytes("favicon.ico", decoded)

{{out}}

[https://rosettacode.org/favicon.ico Rosetta Code Icon]

 

===Manual Implementation===

open System

open System.IO

 

File.WriteAllBytes("favicon.ico", decoded)

{{out}}

[https://rosettacode.org/favicon.ico Rosetta Code Icon]

 

=={{header|Factor}}==

 

"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"

{{out}}

<pre>

Inspired from Wikipedia. Use of a buffer.

May be also of interest : github.com/lietho/base64-forth

 

: char>6bits ( c -- u )

rot - ( addr2 n2 )

;

 

{{out}}

 

=={{header|FreeBASIC}}==

B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _

"abcdefghijklmnopqrstuvwxyz" & _

Print msg64

Print: Print(Decode64(msg64))

{{out}}

<pre>

To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich

</pre>

 

=={{header|Go}}==

As images can no longer be uploaded to RC, I've encoded and decoded a string rather than the Rosetta Code icon.

 

import (

}

fmt.Println("\nDecoded :", string(decoded))

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

 

class Decode {

System.out.println(decodedStr)

}

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

=={{header|Haskell}}==

Simple implementation that decodes an ASCII string.

import qualified Data.Map.Strict as Map (Map, lookup, fromList)

import Data.Maybe (fromJust, listToMaybe, mapMaybe)

putStrLn $

byteToASCII

{{Out}}

<pre>To err is human, but to really foul things up you need a computer.

or in terms of Data.ByteString.Base64:

 

 

import qualified Data.ByteString.Base64 as Base64 (decode, encode)

either print B.putStrLn $

Base64.decode

{{Out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA==

 

=={{header|Haxe}}==

static function main() {

var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" +

Sys.println(decoded);

}

 

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich</pre>

 

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.Base64;

 

System.out.println(decodedStr);

}

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich</pre>

 

=={{header|Jsish}}==

See [[Base64_encode_data#Jsish]] for ''base64.jsi''.

 

var data = exec('jsish base64.jsi', {retAll:true}).data; // or use File.read('stdin');

var icon = Util.base64(data, true);

 

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

 

io = IOBuffer()

 

println(String(read(iob64_decode)))

<pre>

To err is human, but to really foul things up you need a computer.

=={{header|Kotlin}}==

{{trans|D}}

 

fun main() {

val decodedStr = String(decoded, Charsets.UTF_8)

println(decodedStr)

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

 

=={{header|Lua}}==

local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' -- You will need this for encoding/decoding

 

 

local decoded = dec(data)

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo

--Paul R.Ehrlich</pre>

 

"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo",

"Base64"

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

 

=={{header|Nim}}==

 

const Source = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

 

 

{{out}}

 

=={{header|Ol}}==

(define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")

(define kernel (alist->ff (map cons (string->bytes base64-codes) (iota (string-length base64-codes)))))

 

(decode "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=")

{{Out}}

<pre>

=={{header|Perl}}==

The MIME::Base64 module is to be preferred, but this works too.

my($d) = @_;

$d =~ tr!A-Za-z0-9+/!!cd;

EOD

 

{{out}}

<pre>'Twas brillig, and the slithy toves

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PHP}}==

'IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';

echo

$encoded, PHP_EOL,

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

 

=={{header|PicoLisp}}==

`'(chop

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) )

(link

(char (| (>> -6 (& C 3)) D)) ) ) ) ) ) ) ) )

{{out}}

<pre>

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

 

=={{header|Prolog}}==

 

=={{header|PureBasic}}==

"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

 

Base64Decoder(b64cd$, *p_buf, 1024)

OpenConsole("") : PrintN(PeekS(*p_buf, -1, #PB_UTF8))

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

 

=={{header|Python}}==

import base64

data = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='

print(base64.b64decode(data).decode('utf-8'))

{{out}}

<pre>

</pre>

=={{header|QB64}}==

 

Dim As String udata, decoded

Print udata

Print decoded

 

Function findIndex& (value As _Unsigned _Byte)

 

Function encode$ (source As String)

Dim As _Unsigned _Integer64 length: length = Len(source)

Dim As _Unsigned _Integer64 it, strend

it = it + 1

b1 = Asc(Mid$(source, it, 1))

acc = _SHL(b1 And &H3, 4)

If it <> strend Then

b2 = Asc(Mid$(source, it, 1))

acc = acc Or _SHR(b2, 4)

acc = _SHL(b2 And &HF, 2)

If it <> strend Then

b3 = Asc(Mid$(source, it, 1))

acc = acc Or _SHR(b3, 6)

Else

sink = sink + "="

End If

Else

sink = sink + "="

sink = sink + "="

Wend

decode = sink

{{out}}

<pre>

To err is human, but to really foul things up you need a computer.

--Paul R.Ehrlich

</pre>

 

{{works with|Rakudo|2018.11}}

 

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

say "\nFast:";

use Base64::Native;

{{out}}

<pre>Slow:

 

=={{header|Red}}==

 

print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"

{{out}}

<pre>

To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich

</pre>

 

=={{header|Ruby}}==

 

raku_example ='

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

'

{{out}}

<pre>

 

=={{header|Rust}}==

 

const INPUT: &str = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";

 

println!("Output: {}", result);

{{out}}

<pre>

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

 

object Base64Decode extends App {

 

println(text2BinaryDecoding(data))

 

=={{header|Seed7}}==

[http://seed7.sourceforge.net/libraries/encoding.htm#fromBase64(in_string) fromBase64].

 

include "gethttp.s7i";

include "encoding.s7i";

writeln("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: " <&

fromBase64(encoded) = original);

 

{{out}}

<pre>Is the Rosetta Code icon the same (byte for byte) encoded then decoded: TRUE</pre>

 

=={{header|Sidef}}==

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

EOT

 

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

'.

 

{{out}}

<pre>To err is human, but to really foul things up you need a computer.

 

=={{header|Standard ML}}==

let

 

String.implode ( List.map (chr o Word.toInt) ( decodeLst (String.explode input )) )

 

call

<pre>

To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich </pre>

=={{header|Tcl}}==

set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

 

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|D}}

 

Sub Main()

End Sub

 

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

To err is human, but to really foul things up you need a computer.

-- Paul R. Ehrlich</pre>

 

=={{header|Wren}}==

{{libheader|Wren-str}}

From first principles using string manipulation. Quick enough here.

 

var alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

var s = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

for (chunk in Str.chunks(s, 4)) decode.call(chunk)

 

{{out}}

-- Paul R. Ehrlich

</pre>

 

=={{header|zkl}}==

Using shared libraries for cURL and message hashing:

icon:=Curl().get("http://rosettacode.org/favicon.ico"); //-->(Data(4,331),693,0)

File("rosettaCodeIcon.ico","wb").write(iconDecoded); # eyeball checking says good

println("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: ",

{{out}}

<pre>

</pre>

{{out|Text based test}}

println("Original: %s\nEncoded: %s\nBytes: %s\nDecoded: %s"

.fmt(msg, b64.text, b64.bytes().apply("toString",16).concat(","),

<pre>

Original: Rosetta Code Base64 decode data task