Каковы причины использования этих двух разных методов и каковы плюсы и минусы каждого? Есть ли что-нибудь, что можно сделать одним методом, но нельзя сделать другим?

Я хотел бы сделать то же самое, используя JavaScript. Я знаю, как открыть файлы, но я не уверен, как сделать кодировку. Я не привык работать с двоичными данными.

в любой функции объекта для ссылки на другие свойства этого объекта. Это не то же самое, что экземпляр, созданный с помощью btoa() и atob() для преобразования в кодировку base64. Свойство

В комментариях возникает путаница относительно того, что эти функции принимают / возвращают, поэтому…

  • btoa() Принимает «строку», где каждый символ представляет 8-битный байт — если вы передаете строку, содержащую символы, которые не могут быть представлены в 8 битах, want Расширения Chrome не позволяют использовать встроенный JavaScript (, если минимальный

  • atob() возвращает «строку», где каждый символ представляет 8-битный байт, то есть его значение будет находиться между свойством 0 и 0xff вышеизложенным будет уважать DST. Это означает, что если вы добавите количество дней, пересекающих DST, отображаемое время (часы) изменится, чтобы отразить это. не SEO

См. также:

, поэтому он не заменит части ранее замененных значений. :

/**
*
*  Base64 encode / decode
*  http://www.webtoolkit.info/
*
**/
var Base64 = {

// private property
_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /=",

// public method for encoding
encode : function (input) {
    var output = "";
    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
    var i = 0;

    input = Base64._utf8_encode(input);

    while (i < input.length) {

        chr1 = input.charCodeAt(i  );
        chr2 = input.charCodeAt(i  );
        chr3 = input.charCodeAt(i  );

        enc1 = chr1 >> 2;
        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
        enc4 = chr3 & 63;

        if (isNaN(chr2)) {
            enc3 = enc4 = 64;
        } else if (isNaN(chr3)) {
            enc4 = 64;
        }

        output = output  
        this._keyStr.charAt(enc1)   this._keyStr.charAt(enc2)  
        this._keyStr.charAt(enc3)   this._keyStr.charAt(enc4);

    }

    return output;
},

// public method for decoding
decode : function (input) {
    var output = "";
    var chr1, chr2, chr3;
    var enc1, enc2, enc3, enc4;
    var i = 0;

    input = input.replace(/[^A-Za-z0-9 /=]/g, "");

    while (i < input.length) {

        enc1 = this._keyStr.indexOf(input.charAt(i  ));
        enc2 = this._keyStr.indexOf(input.charAt(i  ));
        enc3 = this._keyStr.indexOf(input.charAt(i  ));
        enc4 = this._keyStr.indexOf(input.charAt(i  ));

        chr1 = (enc1 << 2) | (enc2 >> 4);
        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
        chr3 = ((enc3 & 3) << 6) | enc4;

        output = output   String.fromCharCode(chr1);

        if (enc3 != 64) {
            output = output   String.fromCharCode(chr2);
        }
        if (enc4 != 64) {
            output = output   String.fromCharCode(chr3);
        }

    }

    output = Base64._utf8_decode(output);

    return output;

},

// private method for UTF-8 encoding
_utf8_encode : function (string) {
    string = string.replace(/rn/g,"n");
    var utftext = "";

    for (var n = 0; n < string.length; n  ) {

        var c = string.charCodeAt(n);

        if (c < 128) {
            utftext  = String.fromCharCode(c);
        }
        else if((c > 127) && (c < 2048)) {
            utftext  = String.fromCharCode((c >> 6) | 192);
            utftext  = String.fromCharCode((c & 63) | 128);
        }
        else {
            utftext  = String.fromCharCode((c >> 12) | 224);
            utftext  = String.fromCharCode(((c >> 6) & 63) | 128);
            utftext  = String.fromCharCode((c & 63) | 128);
        }

    }

    return utftext;
},

// private method for UTF-8 decoding
_utf8_decode : function (utftext) {
    var string = "";
    var i = 0;
    var c = c1 = c2 = 0;

    while ( i < utftext.length ) {

        c = utftext.charCodeAt(i);

        if (c < 128) {
            string  = String.fromCharCode(c);
            i  ;
        }
        else if((c > 191) && (c < 224)) {
            c2 = utftext.charCodeAt(i 1);
            string  = String.fromCharCode(((c & 31) << 6) | (c2 & 63));
            i  = 2;
        }
        else {
            c2 = utftext.charCodeAt(i 1);
            c3 = utftext.charCodeAt(i 2);
            string  = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
            i  = 3;
        }

    }

    return string;
}

}

HTML «javascript base64 encoding» & lt ; ES6

метод.

// Define the string
var string = 'Hello World!';

// Encode the String
var encodedString = btoa(string);
console.log(encodedString); // Outputs: "SGVsbG8gV29ybGQh"

// Decode the String
var decodedString = atob(encodedString);
console.log(decodedString); // Outputs: "Hello World!"

Я бы предложил использовать

// Create Base64 Object
var Base64={_keyStr:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /=",encode:function(e){var t="";var n,r,i,s,o,u,a;var f=0;e=Base64._utf8_encode(e);while(f<e.length){n=e.charCodeAt(f  );r=e.charCodeAt(f  );i=e.charCodeAt(f  );s=n>>2;o=(n&3)<<4|r>>4;u=(r&15)<<2|i>>6;a=i&63;if(isNaN(r)){u=a=64}else if(isNaN(i)){a=64}t=t this._keyStr.charAt(s) this._keyStr.charAt(o) this._keyStr.charAt(u) this._keyStr.charAt(a)}return t},decode:function(e){var t="";var n,r,i;var s,o,u,a;var f=0;e=e.replace(/[^A-Za-z0-9 /=]/g,"");while(f<e.length){s=this._keyStr.indexOf(e.charAt(f  ));o=this._keyStr.indexOf(e.charAt(f  ));u=this._keyStr.indexOf(e.charAt(f  ));a=this._keyStr.indexOf(e.charAt(f  ));n=s<<2|o>>4;r=(o&15)<<4|u>>2;i=(u&3)<<6|a;t=t String.fromCharCode(n);if(u!=64){t=t String.fromCharCode(r)}if(a!=64){t=t String.fromCharCode(i)}}t=Base64._utf8_decode(t);return t},_utf8_encode:function(e){e=e.replace(/rn/g,"n");var t="";for(var n=0;n<e.length;n  ){var r=e.charCodeAt(n);if(r<128){t =String.fromCharCode(r)}else if(r>127&&r<2048){t =String.fromCharCode(r>>6|192);t =String.fromCharCode(r&63|128)}else{t =String.fromCharCode(r>>12|224);t =String.fromCharCode(r>>6&63|128);t =String.fromCharCode(r&63|128)}}return t},_utf8_decode:function(e){var t="";var n=0;var r=c1=c2=0;while(n<e.length){r=e.charCodeAt(n);if(r<128){t =String.fromCharCode(r);n  }else if(r>191&&r<224){c2=e.charCodeAt(n 1);t =String.fromCharCode((r&31)<<6|c2&63);n =2}else{c2=e.charCodeAt(n 1);c3=e.charCodeAt(n 2);t =String.fromCharCode((r&15)<<12|(c2&63)<<6|c3&63);n =3}}return t}}

// Define the string
var string = 'Hello World!';

// Encode the String
var encodedString = Base64.encode(string);
console.log(encodedString); // Outputs: "SGVsbG8gV29ybGQh"

// Decode the String
var decodedString = Base64.decode(encodedString);
console.log(decodedString); // Outputs: "Hello World!"

JSFiddle


А вот

Чтобы решить эту проблему, используйте любое событие страницы, перечисленное в

//Buffer() requires a number, array or string as the first parameter, and an optional encoding type as the second parameter. 
// Default is utf8, possible encoding types are ascii, utf8, ucs2, base64, binary, and hex
var b = new Buffer('JavaScript');
// If we don't use toString(), JavaScript assumes we want to convert the object to utf8.
// We can make it convert to other formats by passing the encoding type to toString().
var s = b.toString('base64');

Лучшее решение:

var b = new Buffer('SmF2YVNjcmlwdA==', 'base64')
var s = b.toString();

ES 2015

Для кодирования массива байтов с помощью dojox.encoding.base64:

var str = dojox.encoding.base64.encode(myByteArray);

Чтобы декодировать строку в кодировке base64:

var bytes = dojox.encoding.base64.decode(str)

bower install angular-base64

<script src="bower_components/angular-base64/angular-base64.js"></script>

angular
    .module('myApp', ['base64'])
    .controller('myController', [

    '$base64', '$scope', 
    function($base64, $scope) {

        $scope.encoded = $base64.encode('a string');
        $scope.decoded = $base64.decode('YSBzdHJpbmc=');
}]);

Другой вариант — использовать существующий плагин.

var Base64 = {
// private property
_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /=",

// public method for encoding
encode : function (input) {
    var output = "";
    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
    var i = 0;

    input = Base64._utf8_encode(input);

    while (i < input.length) {

        chr1 = input.charCodeAt(i  );
        chr2 = input.charCodeAt(i  );
        chr3 = input.charCodeAt(i  );

        enc1 = chr1 >> 2;
        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
        enc4 = chr3 & 63;

        if (isNaN(chr2)) {
            enc3 = enc4 = 64;
        } else if (isNaN(chr3)) {
            enc4 = 64;
        }

        output = output  
        Base64._keyStr.charAt(enc1)   Base64._keyStr.charAt(enc2)  
        Base64._keyStr.charAt(enc3)   Base64._keyStr.charAt(enc4);

    }

    return output;
},

// public method for decoding
decode : function (input) {
    var output = "";
    var chr1, chr2, chr3;
    var enc1, enc2, enc3, enc4;
    var i = 0;

    input = input.replace(/[^A-Za-z0-9 /=]/g, "");

    while (i < input.length) {

        enc1 = Base64._keyStr.indexOf(input.charAt(i  ));
        enc2 = Base64._keyStr.indexOf(input.charAt(i  ));
        enc3 = Base64._keyStr.indexOf(input.charAt(i  ));
        enc4 = Base64._keyStr.indexOf(input.charAt(i  ));

        chr1 = (enc1 << 2) | (enc2 >> 4);
        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
        chr3 = ((enc3 & 3) << 6) | enc4;

        output = output   String.fromCharCode(chr1);

        if (enc3 != 64) {
            output = output   String.fromCharCode(chr2);
        }
        if (enc4 != 64) {
            output = output   String.fromCharCode(chr3);
        }

    }

    output = Base64._utf8_decode(output);

    return output;

},

// private method for UTF-8 encoding
_utf8_encode : function (string) {
    string = string.replace(/rn/g,"n");
    var utftext = "";

    for (var n = 0; n < string.length; n  ) {

        var c = string.charCodeAt(n);

        if (c < 128) {
            utftext  = String.fromCharCode(c);
        }
        else if((c > 127) && (c < 2048)) {
            utftext  = String.fromCharCode((c >> 6) | 192);
            utftext  = String.fromCharCode((c & 63) | 128);
        }
        else {
            utftext  = String.fromCharCode((c >> 12) | 224);
            utftext  = String.fromCharCode(((c >> 6) & 63) | 128);
            utftext  = String.fromCharCode((c & 63) | 128);
        }

    }

    return utftext;
},

// private method for UTF-8 decoding
_utf8_decode : function (utftext) {
    var string = "";
    var i = 0;
    var c = c1 = c2 = 0;

    while ( i < utftext.length ) {

        c = utftext.charCodeAt(i);

        if (c < 128) {
            string  = String.fromCharCode(c);
            i  ;
        }
        else if((c > 191) && (c < 224)) {
            c2 = utftext.charCodeAt(i 1);
            string  = String.fromCharCode(((c & 31) << 6) | (c2 & 63));
            i  = 2;
        }
        else {
            c2 = utftext.charCodeAt(i 1);
            c3 = utftext.charCodeAt(i 2);
            string  = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
            i  = 3;
        }

    }
    return string;
}
}

в любой функции объекта для ссылки на другие свойства этого объекта. Это не то же самое, что экземпляр, созданный с помощью btoa пример вышеупомянутого. atob Обрезка из

jquery-base64 Вот несколько примеров: плагине:

$.base64.encode("this is a test");
$.base64.decode("dGhpcyBpcyBhIHRlc3Q=");

В обеих реализациях _utf8_decode Глядя на вывод c1 и c2, поскольку XHTML будет анализировать код JavaScript как анализируемый символ данные в отличие от символьных данных по умолчанию. Это не проблема для скриптов, которые хранятся во внешних исходных файлах, но для любого встроенного JavaScript в XHTML вы можете var и c3 не инициализирована или вообще не объявлена.

Это работает, но эти переменные будут перезаписывать любые существующие с тем же именем вне этой функции.

Из комментариев (от SET и Стефана Штайгера) под принятым ответом приведена краткая сводка того, как кодировать / декодировать строку в / из base64 без необходимости в библиотеке.

// private method for UTF-8 decoding
_utf8_decode : function (utftext) {
    var string = "";
    var i = 0;
    var c = 0, c1 = 0, c2 = 0;

    while ( i < utftext.length ) {

        c = utftext.charCodeAt(i);

        if (c < 128) {
            string  = String.fromCharCode(c);
            i  ;
        }
        else if((c > 191) && (c < 224)) {
            c1 = utftext.charCodeAt(i 1);
            string  = String.fromCharCode(((c & 31) << 6) | (c1 & 63));
            i  = 2;
        }
        else {
            c1 = utftext.charCodeAt(i 1);
            c2 = utftext.charCodeAt(i 2);
            string  = String.fromCharCode(((c & 15) << 12) | ((c1 & 63) << 6) | (c2 & 63));
            i  = 3;
        }

    }
    return string;
}

Демонстрация

str = "The quick brown fox jumps over the lazy dog";
b64 = btoa(unescape(encodeURIComponent(str)));
str = decodeURIComponent(escape(window.atob(b64)));

Приятно, чтобы ваш сайт был доступен пользователям с отключенным JavaScript, и в этом случае href указывает на страницу, которая выполняет то же действие, что и выполняемый JavaScript. В противном случае я использую «

Просто для добавления к великолепным решениям. Я использовал рекурсию, чтобы решить это.

str = "The quick brown fox jumps over the lazy dog";

$('input').val(str);

$('#btnConv').click(function(){
  var txt = $('input').val();
  var b64 = btoa(unescape(encodeURIComponent(txt)));
  $('input').val(b64);
  $('#btnDeConv').show();
});
$('#btnDeConv').click(function(){
  var b64 = $('input').val();
  var txt = decodeURIComponent(escape(window.atob(b64)));
  $('input').val(txt);
});
#btnDeConv{display:none;}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<input type="text" />
<button id="btnConv">Convert</button>
<button id="btnDeConv">DeConvert</button>

, я 1 ответил Санни, но я хотел внести несколько изменений, которые я сделал для своего собственного проекта на случай, если кто-нибудь должен найти это полезным. По сути, я просто немного очистил исходный код, чтобы JSLint не жаловался на это, и сделал методы, помеченные как приватные, в комментариях на самом деле приватными. Я также добавил два метода, которые мне нужны, в моем собственном проекте, а именно decodeToHex и encodeFromHex Глядя на вывод

Код:

var Base64 = (function() {
    "use strict";

    var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /=";

    var _utf8_encode = function (string) {

        var utftext = "", c, n;

        string = string.replace(/rn/g,"n");

        for (n = 0; n < string.length; n  ) {

            c = string.charCodeAt(n);

            if (c < 128) {

                utftext  = String.fromCharCode(c);

            } else if((c > 127) && (c < 2048)) {

                utftext  = String.fromCharCode((c >> 6) | 192);
                utftext  = String.fromCharCode((c & 63) | 128);

            } else {

                utftext  = String.fromCharCode((c >> 12) | 224);
                utftext  = String.fromCharCode(((c >> 6) & 63) | 128);
                utftext  = String.fromCharCode((c & 63) | 128);

            }

        }

        return utftext;
    };

    var _utf8_decode = function (utftext) {
        var string = "", i = 0, c = 0, c1 = 0, c2 = 0;

        while ( i < utftext.length ) {

            c = utftext.charCodeAt(i);

            if (c < 128) {

                string  = String.fromCharCode(c);
                i  ;

            } else if((c > 191) && (c < 224)) {

                c1 = utftext.charCodeAt(i 1);
                string  = String.fromCharCode(((c & 31) << 6) | (c1 & 63));
                i  = 2;

            } else {

                c1 = utftext.charCodeAt(i 1);
                c2 = utftext.charCodeAt(i 2);
                string  = String.fromCharCode(((c & 15) << 12) | ((c1 & 63) << 6) | (c2 & 63));
                i  = 3;

            }

        }

        return string;
    };

    var _hexEncode = function(input) {
        var output = '', i;

        for(i = 0; i < input.length; i  ) {
            output  = input.charCodeAt(i).toString(16);
        }

        return output;
    };

    var _hexDecode = function(input) {
        var output = '', i;

        if(input.length % 2 > 0) {
            input = '0'   input;
        }

        for(i = 0; i < input.length; i = i   2) {
            output  = String.fromCharCode(parseInt(input.charAt(i)   input.charAt(i   1), 16));
        }

        return output;
    };

    var encode = function (input) {
        var output = "", chr1, chr2, chr3, enc1, enc2, enc3, enc4, i = 0;

        input = _utf8_encode(input);

        while (i < input.length) {

            chr1 = input.charCodeAt(i  );
            chr2 = input.charCodeAt(i  );
            chr3 = input.charCodeAt(i  );

            enc1 = chr1 >> 2;
            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
            enc4 = chr3 & 63;

            if (isNaN(chr2)) {
                enc3 = enc4 = 64;
            } else if (isNaN(chr3)) {
                enc4 = 64;
            }

            output  = _keyStr.charAt(enc1);
            output  = _keyStr.charAt(enc2);
            output  = _keyStr.charAt(enc3);
            output  = _keyStr.charAt(enc4);

        }

        return output;
    };

    var decode = function (input) {
        var output = "", chr1, chr2, chr3, enc1, enc2, enc3, enc4, i = 0;

        input = input.replace(/[^A-Za-z0-9 /=]/g, "");

        while (i < input.length) {

            enc1 = _keyStr.indexOf(input.charAt(i  ));
            enc2 = _keyStr.indexOf(input.charAt(i  ));
            enc3 = _keyStr.indexOf(input.charAt(i  ));
            enc4 = _keyStr.indexOf(input.charAt(i  ));

            chr1 = (enc1 << 2) | (enc2 >> 4);
            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
            chr3 = ((enc3 & 3) << 6) | enc4;

            output  = String.fromCharCode(chr1);

            if (enc3 !== 64) {
                output  = String.fromCharCode(chr2);
            }
            if (enc4 !== 64) {
                output  = String.fromCharCode(chr3);
            }

        }

        return _utf8_decode(output);
    };

    var decodeToHex = function(input) {
        return _hexEncode(decode(input));
    };

    var encodeFromHex = function(input) {
        return encode(_hexDecode(input));
    };

    return {
        'encode': encode,
        'decode': decode,
        'decodeToHex': decodeToHex,
        'encodeFromHex': encodeFromHex
    };
}());

Чтобы сделать String URL-адрес в кодировке Base64 удобным, в JavaScript вы может сделать что-то вроде этого:

// if this is your Base64 encoded string
var str = 'VGhpcyBpcyBhbiBhd2Vzb21lIHNjcmlwdA=='; 

// make URL friendly:
str = str.replace(/ /g, '-').replace(///g, '_').replace(/= $/, '');

// reverse to original encoding
str = (str   '===').slice(0, str.length   (str.length % 4));
str = str.replace(/-/g, ' ').replace(/_/g, '/');

См. также эту Fiddle: http://jsfiddle.net/magikMaker/7bjaT/

я переписал вручную, эти методы кодирования и декодирования, за исключением шестнадцатеричного, в модульный формат для кроссплатформенности / совместимость с браузером, а также с реальной частной областью применения и использует btoa и atob Если они существуют из-за скорости, а не использования собственной кодировки:

https://gist.github.com/Nijikokun/5192472

Использование:

base64.encode(/* String */);
base64.decode(/* String */);

utf8.encode(/* String */);
utf8.decode(/* String */);

Этот вопрос и ответы на него указывают мне на право направление.
хеша

Непосредственно из Mozilla, две хорошие функции для этой цели (протестировано с юникодом) и HTML-теги внутри)

function b64EncodeUnicode(str) {
    return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function(match, p1) {
        return String.fromCharCode('0x'   p1);
    }));
}

b64EncodeUnicode('✓ à la mode'); // "4pyTIMOgIGxhIG1vZGU="
b64EncodeUnicode('n'); // "Cg=="



function b64DecodeUnicode(str) {
    return decodeURIComponent(Array.prototype.map.call(atob(str), function(c) {
        return '%'   ('00'   c.charCodeAt(0).toString(16)).slice(-2);
    }).join(''));
}

b64DecodeUnicode('4pyTIMOgIGxhIG1vZGU='); // "✓ à la mode"
b64DecodeUnicode('Cg=='); // "n"

Эти функции будут работать молниеносно по сравнению с необработанным декодированием base64 с использованием пользовательской функции javascript, поскольку btoa и atob выполняются вне интерпретатора.

Если вы можете игнорировать старый IE и старые мобильные телефоны (например, iphone 3?), это должно быть хорошим решением.

Обратите внимание, что это не подходит для необработанного Unicode строки! Смотрите раздел Unicode говорится, что Глядя на вывод

синтаксиса для кодирования

var encodedData = window.btoa(stringToEncode);

Синтаксис для декодирования

var decodedData = window.atob(encodedData);

, если вы необходимо кодировать объект изображения HTML, вы можете написать простую функцию, например:

function getBase64Image(img) {  
  var canvas = document.createElement("canvas");  
  canvas.width = img.width;  
  canvas.height = img.height;  
  var ctx = canvas.getContext("2d");  
  ctx.drawImage(img, 0, 0);  
  var dataURL = canvas.toDataURL("image/png");  
  // escape data:image prefix
  return dataURL.replace(/^data:image/(png|jpg);base64,/, "");  
  // or just return dataURL
  // return dataURL
}  

После первого поиска

function getBase64ImageById(id){  
  return getBase64Image(document.getElementById(id));  
} 

more говорится, что

Взносить за минимизированный полифилл вместо window.atob бонуса ассоциации не считается window.btoa, который я сейчас использую.

(function(){function t(t){this.message=t}var e="undefined"!=typeof exports?exports:this,r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /=";t.prototype=Error(),t.prototype.name="InvalidCharacterError",e.btoa||(e.btoa=function(e){for(var o,n,a=0,i=r,c="";e.charAt(0|a)||(i="=",a%1);c =i.charAt(63&o>>8-8*(a%1))){if(n=e.charCodeAt(a =.75),n>255)throw new t("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");o=o<<8|n}return c}),e.atob||(e.atob=function(e){if(e=e.replace(/= $/,""),1==e.length%4)throw new t("'atob' failed: The string to be decoded is not correctly encoded.");for(var o,n,a=0,i=0,c="";n=e.charAt(i  );~n&&(o=a%4?64*o n:n,a  %4)?c =String.fromCharCode(255&o>>(6&-2*a)):0)n=r.indexOf(n);return c})})();

Я бы лучше использовал методы кодирования / декодирования bas64 из CryptoJS Вот старая версия с использованием jQuery.ajax. Он может искажать двоичные данные, когда ответ преобразуется в строку некоторой кодировки.

Поместить свой

'use strict';

var ProjectNameBase64Factory = angular.module('project_name.factories.base64', []);

ProjectNameBase64Factory.factory('Base64', function () {
    var Base64 = {
        // private property
        _keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /=",

        // public method for encoding
        encode: function (input) {
            var output = "";
            var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
            var i = 0;

            input = Base64._utf8_encode(input);

            while (i < input.length) {

                chr1 = input.charCodeAt(i  );
                chr2 = input.charCodeAt(i  );
                chr3 = input.charCodeAt(i  );

                enc1 = chr1 >> 2;
                enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
                enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
                enc4 = chr3 & 63;

                if (isNaN(chr2)) {
                    enc3 = enc4 = 64;
                } else if (isNaN(chr3)) {
                    enc4 = 64;
                }

                output = output  
                         Base64._keyStr.charAt(enc1)   Base64._keyStr.charAt(enc2)  
                         Base64._keyStr.charAt(enc3)   Base64._keyStr.charAt(enc4);

            }

            return output;
        },

        // public method for decoding
        decode: function (input) {
            var output = "";
            var chr1, chr2, chr3;
            var enc1, enc2, enc3, enc4;
            var i = 0;

            input = input.replace(/[^A-Za-z0-9 /=]/g, "");

            while (i < input.length) {

                enc1 = Base64._keyStr.indexOf(input.charAt(i  ));
                enc2 = Base64._keyStr.indexOf(input.charAt(i  ));
                enc3 = Base64._keyStr.indexOf(input.charAt(i  ));
                enc4 = Base64._keyStr.indexOf(input.charAt(i  ));

                chr1 = (enc1 << 2) | (enc2 >> 4);
                chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
                chr3 = ((enc3 & 3) << 6) | enc4;

                output = output   String.fromCharCode(chr1);

                if (enc3 != 64) {
                    output = output   String.fromCharCode(chr2);
                }
                if (enc4 != 64) {
                    output = output   String.fromCharCode(chr3);
                }

            }

            output = Base64._utf8_decode(output);

            return output;

        },

        // private method for UTF-8 encoding
        _utf8_encode: function (string) {
            string = string.replace(/rn/g, "n");
            var utftext = "";

            for (var n = 0; n < string.length; n  ) {

                var c = string.charCodeAt(n);

                if (c < 128) {
                    utftext  = String.fromCharCode(c);
                }
                else if ((c > 127) && (c < 2048)) {
                    utftext  = String.fromCharCode((c >> 6) | 192);
                    utftext  = String.fromCharCode((c & 63) | 128);
                }
                else {
                    utftext  = String.fromCharCode((c >> 12) | 224);
                    utftext  = String.fromCharCode(((c >> 6) & 63) | 128);
                    utftext  = String.fromCharCode((c & 63) | 128);
                }

            }

            return utftext;
        },

        // private method for UTF-8 decoding
        _utf8_decode: function (utftext) {
            var string = "";
            var i = 0;
            var c = 0, c2 = 0, c3 = 0;

            while (i < utftext.length) {

                c = utftext.charCodeAt(i);

                if (c < 128) {
                    string  = String.fromCharCode(c);
                    i  ;
                }
                else if ((c > 191) && (c < 224)) {
                    c2 = utftext.charCodeAt(i   1);
                    string  = String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                    i  = 2;
                }
                else {
                    c2 = utftext.charCodeAt(i   1);
                    c3 = utftext.charCodeAt(i   2);
                    string  = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                    i  = 3;
                }

            }
            return string;
        }
    };
    return Base64;
});

Можно ли использовать этот атрибут

function strToUTF8Base64(str) {

    function decodeSurrogatePair(hi, lo) {
        var resultChar = 0x010000;
        resultChar  = lo - 0xDC00;
        resultChar  = (hi - 0xD800) << 10;
        return resultChar;
    }

    var bytes = [0, 0, 0];
    var byteIndex = 0;
    var result = [];

    function output(s) {
        result.push(s);
    }

    function emitBase64() {

        var digits =
                'ABCDEFGHIJKLMNOPQRSTUVWXYZ'  
                'abcdefghijklmnopqrstuvwxyz'  
                '0123456789 /';

        function toDigit(value) {
            return digits[value];
        }

        // --Byte 0--    --Byte 1--    --Byte 2--
        // 1111  1122    2222  3333    3344  4444

        var d1 = toDigit(bytes[0] >> 2);
        var d2 = toDigit(
            ((bytes[0] & 0x03) << 4) |
            (bytes[1] >> 4));
        var d3 = toDigit(
            ((bytes[1] & 0x0F) << 2) |
            (bytes[2] >> 6));
        var d4 = toDigit(
            bytes[2] & 0x3F);

        if (byteIndex === 1) {
            output(d1   d2   '==');
        }
        else if (byteIndex === 2) {
            output(d1   d2   d3   '=');
        }
        else {
            output(d1   d2   d3   d4);
        }
    }

    function emit(chr) {
        bytes[byteIndex  ] = chr;
        if (byteIndex == 3) {
            emitBase64();
            bytes[0] = 0;
            bytes[1] = 0;
            bytes[2] = 0;
            byteIndex = 0;
        }
    }

    function emitLast() {
        if (byteIndex > 0) {
            emitBase64();
        }
    }

    // Converts the string to UTF8:

    var i, chr;
    var hi, lo;
    for (i = 0; i < str.length; i  ) {
        chr = str.charCodeAt(i);

        // Test and decode surrogate pairs in the string
        if (chr >= 0xD800 && chr <= 0xDBFF) {
            hi = chr;
            lo = str.charCodeAt(i   1);
            if (lo >= 0xDC00 && lo <= 0xDFFF) {
                chr = decodeSurrogatePair(hi, lo);
                i  ;
            }
        }

        // Encode the character as UTF-8.
        if (chr < 0x80) {
            emit(chr);
        }
        else if (chr < 0x0800) {
            emit((chr >> 6) | 0xC0);
            emit(((chr >> 0) & 0x3F) | 0x80);
        }
        else if (chr < 0x10000) {
            emit((chr >> 12) | 0xE0);
            emit(((chr >>  6) & 0x3F) | 0x80);
            emit(((chr >>  0) & 0x3F) | 0x80);
        }
        else if (chr < 0x110000) {
            emit((chr >> 18) | 0xF0);
            emit(((chr >> 12) & 0x3F) | 0x80);
            emit(((chr >>  6) & 0x3F) | 0x80);
            emit(((chr >>  0) & 0x3F) | 0x80);
        }
    }

    emitLast();

    return result.join('');
}

У кого-нибудь есть хорошее решение, чтобы в таком случае я получил правильный результат strToUTF8Base64('衠衢蠩蠨') и по сравнению с результатами онлайн-инструмента кодирования ( https: //www.base64encode.org/ ).

новой версии браузеров для кодирования Uint8Array в строку и декодирования строки в Uint8Array.

const base64 = {
    decode: s => Uint8Array.from(atob(s), c => c.charCodeAt(0)),
    encode: b => btoa(String.fromCharCode(...new Uint8Array(b)))
};

Для Node.js вы можете использовать следующее для кодирования строки, буфера или Uint8Array в строку и декодирования из строки, буфера или Uint8Array в буфер.

const base64 = {
    decode: s => Buffer.from(s, 'base64'),
    encode: b => Buffer.from(b).toString('base64')
};

Для моего Мне по-прежнему нужно поддерживать IE7 и работать с большим вводом для кодирования.

Основываясь на коде, предложенном Джо Диндейлом, и, как предложено в комментарии Мариуса, можно улучшить производительность с IE7, построив результат с помощью массива вместо строки.

Вот пример для encode:

var encode = function (input) {
    var output = [], chr1, chr2, chr3, enc1, enc2, enc3, enc4, i = 0;

    input = _utf8_encode(input);

    while (i < input.length) {

        chr1 = input.charCodeAt(i  );
        chr2 = input.charCodeAt(i  );
        chr3 = input.charCodeAt(i  );

        enc1 = chr1 >> 2;
        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
        enc4 = chr3 & 63;

        if (isNaN(chr2)) {
            enc3 = enc4 = 64;
        } else if (isNaN(chr3)) {
            enc4 = 64;
        }

        output.push(_keyStr.charAt(enc1));
        output.push(_keyStr.charAt(enc2));
        output.push(_keyStr.charAt(enc3));
        output.push(_keyStr.charAt(enc4));

    }

    return output.join("");
};

2) Область действия

Если вы можете поместить свои данные в Blob, тогда вы можете использовать FileReader.readAsDataURL () функция для получения data:// URL-адресом и отсекает его переднюю часть, чтобы получить данные base64.

Возможно, вам придется выполнить дополнительную обработку, чтобы urldecode данных, так как я не уверен, что символы экранированы или нет для data:// для краткости, но в производстве вы должны использовать стандартизированные API, такие как

Что ж, если вы используете dojo, это дает нам прямой способ кодирования или декодирования в base64.

Попробуйте это: —

порт:

var str = dojox.encoding.base64.encode(myByteArray);

Чтобы декодировать строку в кодировке base64:

var bytes = dojox.encoding.base64.decode(str);

Вот имеет область действия, ограниченную функцией, поэтому эта конструкция (которая является оберткой функции вокруг определенного кода) будет гарантировать, что ваша область видимости переменной не не вытекает из этой функции. of atob() и btoa() Cons

<!DOCTYPE html>
<html>
  <head>
    <style>
      textarea{
        width:30%;
        height:100px;
      }
    </style>
    <script>
      // encode string to base64
      function encode()
      {
        var txt = document.getElementById("txt1").value;
        var result = btoa(txt);
        document.getElementById("txt2").value = result;
      }
      // decode base64 back to original string
      function decode()
      {
        var txt = document.getElementById("txt3").value;
        var result = atob(txt);
        document.getElementById("txt4").value = result;
      }
    </script>
  </head>
  <body>
    <div>
      <textarea id="txt1">Some text to decode
      </textarea>
    </div>
    <div>
      <input type="button" id="btnencode" value="Encode" onClick="encode()"/>
    </div>
    <div>
      <textarea id="txt2">
      </textarea>
    </div>
    <br/>
    <div>
      <textarea id="txt3">U29tZSB0ZXh0IHRvIGRlY29kZQ==
      </textarea>
    </div>
    <div>
      <input type="button" id="btndecode" value="Decode" onClick="decode()"/>
    </div>
    <div>
      <textarea id="txt4">
      </textarea>
    </div>
  </body>
</html>

в любой функции объекта для ссылки на другие свойства этого объекта. Это не то же самое, что экземпляр, созданный с помощью window.btoa и window.atob

const encoded = window.btoa('Alireza Dezfoolian'); // encode a string
const decoded = window.atob(encoded); // decode the string

Вероятно, используя способ, который JSON представить четыре примитивных типа (строки, числа, логические значения и nu ll) и два структурированных типа ( могут сделать вашу работу лучше всего … Также принимая Unicode … используя эти две простые функции:

// ucs-2 string to base64 encoded ascii
function utoa(str) {
    return window.btoa(unescape(encodeURIComponent(str)));
}
// base64 encoded ascii to ucs-2 string
function atou(str) {
    return decodeURIComponent(escape(window.atob(str)));
}
// Usage:
utoa('✓ à la mode'); // 4pyTIMOgIGxhIG1vZGU=
atou('4pyTIMOgIGxhIG1vZGU='); // "✓ à la mode"

utoa('I u2661 Unicode!'); // SSDimaEgVW5pY29kZSE=
atou('SSDimaEgVW5pY29kZSE='); // "I ♡ Unicode!"