Base64 decode data: Difference between revisions

 

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

IF b>='A AND b<='Z THEN

RETURN (b-'A)

PROC Main()

Test("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo")

{{out}}

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

=={{header|Ada}}==

{{libheader|AWS}}

 

with AWS.Translator;

Ada.Text_IO.New_Line;

Ada.Text_IO.Put_Line (Result);

 

{{out}}

=={{header|Arturo}}==

 

 

 

{{out}}

=={{header|BaCon}}==

Using the result from the [[Base64 encode data]] task as requested, but the result is abbreviated in the code below.

ico$ = B64DEC$(data$)

 

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

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

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

=={{header|Clojure}}==

 

(String. (.decode (java.util.Base64/getDecoder) str)))

 

(decode "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=")

 

{{out}}

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=

 

=={{header|Dart}}==

 

void main() {

var decoded = utf8.decode(base64.decode(encoded));

print(decoded);

 

{{out}}

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

end.

{{out}}

<pre>Source string:

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

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

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

using J's [https://github.com/jsoftware/convert_misc/blob/master/base64.ijs convert/misc/base64] script:

 

frombase64 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='

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

 

Alternative implementation based on that script:

 

BASE64=: (a.{~ ,(a.i.'Aa') +/i.26),'0123456789+/'

 

pad }. a. {~ #. _8 [\ , (6#2) #: BASE64 i. y

}}

 

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

=={{header|JavaScript}}==

=== Browser ===

const base64 = 'SGVsbG8sIHdvcmxkIQ==';

// atob is a built-in function.

=== Node.js ===

const base64 = Buffer.from('SGVsbG8sIHdvcmxkIQ==', 'base64');

// <Buffer>.toString() is a built-in method.

{{out}}

<pre>Hello, world!</pre>

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

 

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

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

<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: #0000FF;">?</span><span style="color: #000000;">e</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">decode_base64</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)</span>

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

Wend

decode = sink

{{out}}

<pre>

{{works with|R|4.1.0}}

{{libheader|base64enc}}

"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |>

base64enc::base64decode() |>

rawToChar() |>

cat()

<pre>

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

{{works with|Rakudo|2018.11}}

 

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

say "\nFast:";

use Base64::Native;

{{out}}

<pre>Slow:

 

=={{header|Red}}==

 

print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"

{{out}}

<pre>

 

=={{header|Ring}}==

#======================================#

# Sample: Base64 decode data

oQByteArray.append(oba)

see oQByteArray.fromBase64(oQByteArray).data()

{{out}}

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

 

=={{header|SenseTalk}}==

 

put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=")

 

 

Output:

 

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

-- Paul R. Ehrlich </pre>

=={{header|Tcl}}==

set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

 

{{out}}

<pre>

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

{{trans|D}}

 

Sub Main()

End Sub

 

{{out}}

<pre>VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

 

=={{header|Vlang}}==

 

fn main() {

decoded := base64.decode_str(encoded)

println("\nDecoded : $decoded")

 

{{out}}

{{libheader|Wren-str}}

From first principles using string manipulation. Quick enough here.

import "/fmt" for Conv, Fmt

import "/str" for Str

var s = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

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

 

{{out}}

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