Base64 encode data: Difference between revisions

 

=={{header|ABAP}}==

lv_encoded TYPE string,

lv_data TYPE xstring.

ENDWHILE.

WRITE: / lv_encoded.

 

{{out}}

...

AAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=

</pre>

 

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

 

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

<pre>AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAA

 

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

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

<pre>AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4F...AAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=</pre>

 

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

AAABAAIAEBAAAAAAAABoBQAAJgAAACAg...AAABAAAAAQAAAAEAAAABAAAAAQAAAAE=

</pre>

 

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

 

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

AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgA

AAAAAQAAAAEAAAABAAAAAQAAAAE=prompt$</pre>

 

=={{header|Julia}}==

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

AAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=

</pre>

 

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

Very interesting results.

{{out}}

AAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEA

AAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE=</pre>

 

=={{header|Objective-C}}==

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

{{out}}

<pre>

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

n the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure."

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

────────────────────────────────────base64─────────────────────────────────────

YW55IGNhcm5hbCBwbGVhcw==

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

Output:

...

 

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

Result of string comparison of input and decoded output: 0.

A zero indicates both strings are equal.</pre>

 

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