Base64 encode data: Difference between revisions

=={{header|ABAP}}==

lv_encoded TYPE string,

lv_data TYPE xstring.

ENDWHILE.

WRITE: / lv_encoded.

{{out}}

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

{{libheader|Action! Tool Kit}}

PROC Encode(BYTE ARRAY buf BYTE len CHAR ARRAY res)

PROC Main()

EncodeFile("H1:FAVICON.ICO")

{{out}}

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

=={{header|Ada}}==

{{libheader|AWS}}

with AWS.Response;

begin

Ada.Text_IO.Put_Line (Icon_64);

{{out}}

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

This program is run on a modified Algol 68 Genie 2.8. That interpreter has some bugs, so it does not do binary tcp/ip requests, and I made patches/bugfixes to it in order to run this task.

STRING codes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[@0];

STRING encoded icon = base64_encode (rosettacode icon);

print ((encoded icon, new line))

{{out}}

<pre>

=={{header|ARM Assembly}}==

.section .rodata

ch64: .ascii "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

mov r0, #0

swi #0

=={{header|BaCon}}==

binary = BLOAD(file$)

PRINT B64ENC$(binary, FILELEN(file$))

{{out}}

<pre>AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAE.......QAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=</pre>

===libresolv===

{{libheader|libresolv}} (libresolv is included on most Unix-like systems)

#include <stdlib.h>

#include <resolv.h>

return 0;

Compile with

<pre>gcc -lresolv -o base64encode base64encode.c</pre>

===Manual implementation===

The following reads standard input and writes base64-encoded stream to standard output, e.g. <tt>./a.out <some_random_file >/dev/null</tt> if you don't want to see the output. It gives identical output as the common <tt>base64</tt> utility program, though much less efficiently.

#include <unistd.h>

return 0;

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

{

using System;

}

}

Output:

<pre>AAABAAIAEBAAAAAAAABoBQAAJgAAACAg...AAABAAAAAQAAAAEAAAABAAAAAQAAAAE=</pre>

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

#include <iostream>

#include <fstream>

return 0;

}

{{out}}

<pre>

Assumes the source file is a PRG on disk drive device 8, writes encoded file both to a SEQ file on the same disk and to the screen (where it looks good in 80-column mode on a PET or C128, a little less so on a C64 or VIC). This is all done in PETSCII; transfer out of Commodore-land will require translation of the Base64-encoded file into ASCII.

100 print chr$(247);chr$(14);

110 dim a$(63): rem alphabet

450 print "error:"st

460 open 15,8,15:input#15,ds,ds$,a,b:close15

{{Out}}

A nice example for the CL eco system using [http://quickdocs.org/cl-base64/ cl-base64] and [https://www.cliki.net/Drakma drakma].

(ql:quickload "drakma")

(ql:quickload "cl-base64"))

finally (return (usb8-array-to-base64-string array)))))

(close input)

{{out}}

<pre>"AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAEABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///...</pre>

=={{header|Crystal}}==

require "http/client"

require "base64"

Base64.encode(response.body, STDOUT)

end

=={{header|D}}==

import std.stdio, std.base64, std.net.curl, std.string;

const f = "http://rosettacode.org/favicon.ico".get.representation;

Base64.encode(f).writeln;

{{out}}

<pre>AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAwqgIAADCjgUAACgAAAAQAAAAIAA...

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

uses IdHTTP, IdCoderMIME;

lHTTP.Free;

end;

=={{header|Elixir}}==

encoded = :base64.encode(data)

{{out}}

=={{header|Erlang}}==

-export([main/0]).

%% Demonstrating with the library function.

encode_library(Data) ->

{{out}}

===Standard Library===

{{works with|fsharp|4.5}}

open System.Net

let encoded = Convert.ToBase64String raw

{{out}}

===Manual Implementation===

{{works with|fsharp|4.5}}

let encode s =

printfn "%s" encoded

{{out}}

=={{header|Factor}}==

"http://rosettacode.org/favicon.ico" http-get nip

{{out}}

<pre>

Inspired from Wikipedia. Use of a buffer.

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

: alphabase ( u -- c ) $3F and C" ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" 1+ + c@ ;

dup here swap - ( addr2 n2 )

;

{{out}}

=={{header|FreeBASIC}}==

B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _

"abcdefghijklmnopqrstuvwxyz" & _

Print msg64

Print: Print(Encode64(msg64))

{{out}}

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

=={{header|Go}}==

===Standard Library===

import (

}

fmt.Println(base64.StdEncoding.EncodeToString(d))

{{out}}

<pre>

</pre>

===Manual implementation===

// A port, with slight variations, of the C version found here:

// http://rosettacode.org/wiki/Base64#C (manual implementation)

}

fmt.Printf("%s", encoded)

{{out}}

<pre>

{{Trans|C}}

This Haskell code is ported from the C solution (manual implementation) with slight variations.

-- A port, with slight variations, of the C version found here:

-- http://rosettacode.org/wiki/Base64#C (manual implementation)

main :: IO ()

===Using Data.ByteString.Base64===

import qualified Data.ByteString.Char8 as B (putStrLn, readFile)

main :: IO ()

=={{header|J}}==

padB64 =: , '=' #~ 0 2 1 i. 3 | #

76 {. tobase64 gethttp 'http://rosettacode.org/favicon.ico'

=={{header|Java}}==

Can also use org.apache.commons.codec.binary.Base64 from Apache Commons Codec

import java.io.IOException;

import java.io.InputStream;

}

}

<pre>AAABAAIAEBAAAAAAAABoBQ...QAAAAEAAAABAAAAAQAAAAE=</pre>

=== Java 8 version ===

import java.util.Base64;

System.out.println(result);

}

<pre>AAABAAIAEBAAAAAAAABoBQ...QAAAAEAAAABAAAAAQAAAAE=</pre>

=={{header|JavaScript}}==

function stringToArrayUnicode(str){for(var i=0,l=str.length,n=[];i<l;i++)n.push(str.charCodeAt(i));return n;}

function generateOnesByLength(n){//Attempts to generate a binary number full of ones given a length.. they don't redefine each other that much.

return toBase64(stringToArrayUnicode("Nothing seems hard to the people who don't know what they're talking about."))

===Using btoa (HTML5)===

HTML5 saves the day! introducing two methods to the DOM!

These are btoa and atob, see [http://dev.w3.org/html5/spec-LC/webappapis.html#atob spec]

JSON.stringify it or..

encodeURIComponent it.

===Using Node.js===

{{works with|Node.js}}

var options = {

host: 'rosettacode.org',

});

}

=={{header|Jsish}}==

<nowiki>https://jsish.org/fossil/jsi/wiki/Wget</nowiki> and also listed at [[HTTP#Jsish]].

require('httpGet');

var icon = httpGet('http://rosettacode.org/favicon.ico');

{{out}}

{{works with|Julia|0.6}}

file = read(get("https://rosettacode.org/favicon.ico"))

encoded = base64encode(file)

{{out}}

=={{header|Kotlin}}==

import java.io.File

val base64 = Base64.getEncoder().encodeToString(bytes)

println(base64)

{{out}}

=={{header|Lasso}}==

src = curl('http://rosettacode.org/favicon.ico'),

srcdata = #src->result

// or, in one movement:

=={{header|LiveCode}}==

put base64encode(rosettaico)

Ouput

=={{header|Lua}}==

local dic = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

function encode( t, f )

end

print()

{{out}}

<pre>

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

Very interesting results.

{{out}}

=={{header|Nim}}==

import httpclient

echo encoded

else:

{{out}}

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

{{works with|iOS|4.0+}}

int main(int argc, const char *argv[]) {

}

return 0;

=={{header|OCaml}}==

=={{header|Ol}}==

(define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")

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

(encode "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.")

{{Out}}

<pre>

The rosettacode icon:

(define icon (runes->string (bytevector->list (file->bytevector "favicon.ico"))))

(encode icon)

<pre>

AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAEABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///wCG

=={{header|Perl}}==

use strict;

use warnings;

local $/;

print encode_base64(<$fh>);

{{out}}

=={{header|Phix}}==

For simplicity, the example from wp:

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

This downloads, encodes, decodes, and verifies the icon:

{{libheader|Phix/libcurl}}

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">url</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"https://rosettacode.org/favicon.ico"</span><span style="color: #0000FF;">,</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"base 64: %s, same: %t\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b64</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"chars"</span><span style="color: #0000FF;">),</span><span style="color: #000000;">chk</span><span style="color: #0000FF;">==</span><span style="color: #000000;">raw</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|PHP}}==

=={{header|PicoLisp}}==

(setq *Char64

`'(chop

(test

"c3VyZS4="

=={{header|Pike}}==

string icon = Protocols.HTTP.get_url_data("http://rosettacode.org/favicon.ico");

// The default base64 encodeing linefeeds every 76 chars

// For brivety, just print the first and last line

write("%s\n...\n%s\n", encoded_lines[0], encoded_lines[-1]);

{{Out}}

<pre>

=={{header|PowerShell}}==

$bytes = $webClient.DownloadData('http://rosettacode.org/favicon.ico')

$output = [Convert]::ToBase64String($bytes)

{{out}}

<pre>

=={{header|PureBasic}}==

*BufferRaw = ReceiveHTTPMemory("http://rosettacode.org/favicon.ico")

Else

Debug "Download failed"

=={{header|Python}}==

import base64

data = urllib.urlopen('http://rosettacode.org/favicon.ico').read()

(For me this gets the wrong data; the data is actually an error message. But still, it base-64 encodes it.)

=={{header|Racket}}==

#lang racket

(require net/url net/base64)

(base64-encode (call/input-url (string->url "http://rosettacode.org/favicon.ico")

get-pure-port port->bytes))

Output:

#"AAABAAIAEBAAAAAAAABoBQAA...AQAAAAE=\r\n"

=={{header|Raku}}==

(formerly Perl 6)

my $buf = slurp("./favicon.ico", :bin);

say buf-to-Base64($buf);

else { take '==' }

}

{{out}}

<pre>AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAA...QAAAAEAAAABAAAAAQAAAAE=</pre>

=={{header|Red}}==

print enbase read/binary https://rosettacode.org/favicon.ico

{{out}}

<pre>

A much higher value for &nbsp; '''chunk''' &nbsp; could be used for modern systems or implementations.

parse arg iFID @ /*obtain optional arguments from the CL*/

if iFID=='' | iFID=="," then iFID='favicon.ico' /*Not specified? Then use the default.*/

end /*j*/

/* [↓] maybe append equal signs to $. */

For the various outputs, several input texts from the Wikipedia article on &nbsp; ''Base64'' &nbsp; [http://en.wikipedia.org/wiki/Base64] &nbsp; were used to demonstrate how padding works.

<br><br>

=={{header|Ring}}==

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

# Description : Base64 Sample

oQByteArray.append("bXkgc3RyaW5n")

? oQByteArray.fromBase64(oQByteArray).data()

{{out}}

<pre>

=={{header|Ruby}}==

require 'base64'

=={{header|Scala}}==

import java.util.Base64

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

=={{header|Seed7}}==

which encodes a string with the Base64 encoding.

include "gethttp.s7i";

include "encoding.s7i";

begin

writeln(toBase64(getHttp("rosettacode.org/favicon.ico")));

=={{header|SenseTalk}}==

put "To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich" as base64

put base64Encode ("To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich")

Output:

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVk

IGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=

VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVk

IGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=

=={{header|Sidef}}==

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

package require http

http::cleanup $tok

With older versions of Tcl, the base64 encoding is best supported via an external package:

{{tcllib|base64}}

package require http

http::cleanup $tok

=={{header|VBA}}==

Public Function Decode(s As String) As String

Dim i As Integer, j As Integer, r As Byte

Debug.Print "Result of string comparison of input and decoded output: " & StrComp(In_, bIn, vbBinaryCompare)

Debug.Print "A zero indicates both strings are equal."

{{out}}<pre>The first eighty and last eighty characters after encoding:

AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAEAB

{{libheader|Wren-seq}}

From first principles using string manipulation. Quick enough here.

import "/fmt" for Conv, Fmt

import "/seq" for Lst

var s = File.read("favicon.ico").bytes.toList

for (chunk in Lst.chunks(s, 3)) encode.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)

icon==MsgHash.base64decode(b64));

b64.println();

{{out}}

Encoded to 72 characters per line