Base64 decode data: Difference between revisions

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

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

RETURN (b-'A)

=={{header|Ada}}==

{{libheader|AWS}}

with AWS.Translator;

=={{header|Arturo}}==

print decode text</syntaxhighlight>

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

BSAVE ico$ TO "favicon.ico" SIZE LEN(ico$)</syntaxhighlight>

=={{header|Bash}}==

{{trans|Bash}}

declare -a encodeTable=(

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

=={{header|C}}==

{{trans|C++}}

#include <stdlib.h>

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

{{trans|Visual Basic .NET}}

using System.Text;

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

{{Works with|C++14}}

#include <iostream>

#include <string>

=={{header|Clojure}}==

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

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

=={{header|Crystal}}==

encoded_string = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

=={{header|D}}==

{{trans|Raku}}

import std.stdio;

=={{header|Dart}}==

void main() {

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

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

===Standard Library===

open System

open System.IO

===Manual Implementation===

open System

open System.IO

=={{header|Factor}}==

"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"

Inspired from Wikipedia. Use of a buffer.

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

: char>6bits ( c -- u )

=={{header|FreeBASIC}}==

B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _

"abcdefghijklmnopqrstuvwxyz" & _

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

=={{header|Groovy}}==

{{trans|Java}}

class Decode {

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

or in terms of Data.ByteString.Base64:

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

=={{header|Haxe}}==

static function main() {

var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" +

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+/'

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.Base64;

=={{header|JavaScript}}==

=== Browser ===

const base64 = 'SGVsbG8sIHdvcmxkIQ==';

// atob is a built-in function.

console.log(atob(base64));</syntaxhighlight>

=== Node.js ===

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

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

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

=={{header|Kotlin}}==

{{trans|D}}

fun main() {

=={{header|Lua}}==

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

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

"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo",

"Base64"

=={{header|Nim}}==

const Source = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

=={{header|Ol}}==

(define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")

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

=={{header|Perl}}==

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

my($d) = @_;

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

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

=={{header|PHP}}==

'IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';

echo

=={{header|PicoLisp}}==

`'(chop

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) )

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

=={{header|PureBasic}}==

"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="

=={{header|Python}}==

import base64

data = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='

</pre>

=={{header|QB64}}==

Dim As String udata, decoded

{{works with|R|4.1.0}}

{{libheader|base64enc}}

"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |>

base64enc::base64decode() |>

{{works with|Rakudo|2018.11}}

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

=={{header|Red}}==

print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"

=={{header|Ring}}==

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

# Sample: Base64 decode data

=={{header|Ruby}}==

raku_example ='

=={{header|Rust}}==

const INPUT: &str = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";

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

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

include "gethttp.s7i";

include "encoding.s7i";

=={{header|SenseTalk}}==

put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=")

Output:

=={{header|Sidef}}==

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2

9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

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

let

-- Paul R. Ehrlich </pre>

=={{header|Tcl}}==

set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=

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

{{trans|D}}

Sub Main()

=={{header|Vlang}}==

fn main() {

{{libheader|Wren-str}}

From first principles using string manipulation. Quick enough here.

import "/fmt" for Conv, Fmt

import "/str" for Str

=={{header|zkl}}==

Using shared libraries for cURL and message hashing:

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

</pre>

{{out|Text based test}}

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

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