2012-07-17 16 views
21

Sto tentando di utilizzare atob per convertire i dati codificati base64 in stringa. Ho trovato che funziona bene in Mozilla e Chrome, ma non funziona in IE. Ti prego, dimmi qualsiasi substitue per questo, o come fare questo lavoro in IEnon funziona in IE

+3

Prova questo: http://code.google.com/p/stringencoders/source/browse/trunk /javascript/base64.js?r=230 –

+1

Microsoft ha finalmente aggiunto il supporto nativo per 'atob' e' btoa' in Internet Explorer 10. – some

risposta

37

Vai a questo link per inserire js momento non vi:

http://code.google.com/p/stringencoders/source/browse/trunk/javascript/base64.js?r=230

/* 
* Copyright (c) 2010 Nick Galbreath 
* See full license on http://code.google.com/p/stringencoders/source/browse/#svn/trunk/javascript 
*/ 

var base64 = {}; 
base64.PADCHAR = '='; 
base64.ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/'; 

base64.makeDOMException = function() { 
    // sadly in FF,Safari,Chrome you can't make a DOMException 
    var e, tmp; 

    try { 
     return new DOMException(DOMException.INVALID_CHARACTER_ERR); 
    } catch (tmp) { 
     // not available, just passback a duck-typed equiv 
     // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Error 
     // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Error/prototype 
     var ex = new Error("DOM Exception 5"); 

     // ex.number and ex.description is IE-specific. 
     ex.code = ex.number = 5; 
     ex.name = ex.description = "INVALID_CHARACTER_ERR"; 

     // Safari/Chrome output format 
     ex.toString = function() { return 'Error: ' + ex.name + ': ' + ex.message; }; 
     return ex; 
    } 
} 

base64.getbyte64 = function(s,i) { 
    // This is oddly fast, except on Chrome/V8. 
    // Minimal or no improvement in performance by using a 
    // object with properties mapping chars to value (eg. 'A': 0) 
    var idx = base64.ALPHA.indexOf(s.charAt(i)); 
    if (idx === -1) { 
     throw base64.makeDOMException(); 
    } 
    return idx; 
} 

base64.decode = function(s) { 
    // convert to string 
    s = '' + s; 
    var getbyte64 = base64.getbyte64; 
    var pads, i, b10; 
    var imax = s.length 
    if (imax === 0) { 
     return s; 
    } 

    if (imax % 4 !== 0) { 
     throw base64.makeDOMException(); 
    } 

    pads = 0 
    if (s.charAt(imax - 1) === base64.PADCHAR) { 
     pads = 1; 
     if (s.charAt(imax - 2) === base64.PADCHAR) { 
      pads = 2; 
     } 
     // either way, we want to ignore this last block 
     imax -= 4; 
    } 

    var x = []; 
    for (i = 0; i < imax; i += 4) { 
     b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12) | 
      (getbyte64(s,i+2) << 6) | getbyte64(s,i+3); 
     x.push(String.fromCharCode(b10 >> 16, (b10 >> 8) & 0xff, b10 & 0xff)); 
    } 

    switch (pads) { 
    case 1: 
     b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12) | (getbyte64(s,i+2) << 6); 
     x.push(String.fromCharCode(b10 >> 16, (b10 >> 8) & 0xff)); 
     break; 
    case 2: 
     b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12); 
     x.push(String.fromCharCode(b10 >> 16)); 
     break; 
    } 
    return x.join(''); 
} 

base64.getbyte = function(s,i) { 
    var x = s.charCodeAt(i); 
    if (x > 255) { 
     throw base64.makeDOMException(); 
    } 
    return x; 
} 

base64.encode = function(s) { 
    if (arguments.length !== 1) { 
     throw new SyntaxError("Not enough arguments"); 
    } 
    var padchar = base64.PADCHAR; 
    var alpha = base64.ALPHA; 
    var getbyte = base64.getbyte; 

    var i, b10; 
    var x = []; 

    // convert to string 
    s = '' + s; 

    var imax = s.length - s.length % 3; 

    if (s.length === 0) { 
     return s; 
    } 
    for (i = 0; i < imax; i += 3) { 
     b10 = (getbyte(s,i) << 16) | (getbyte(s,i+1) << 8) | getbyte(s,i+2); 
     x.push(alpha.charAt(b10 >> 18)); 
     x.push(alpha.charAt((b10 >> 12) & 0x3F)); 
     x.push(alpha.charAt((b10 >> 6) & 0x3f)); 
     x.push(alpha.charAt(b10 & 0x3f)); 
    } 
    switch (s.length - imax) { 
    case 1: 
     b10 = getbyte(s,i) << 16; 
     x.push(alpha.charAt(b10 >> 18) + alpha.charAt((b10 >> 12) & 0x3F) + 
       padchar + padchar); 
     break; 
    case 2: 
     b10 = (getbyte(s,i) << 16) | (getbyte(s,i+1) << 8); 
     x.push(alpha.charAt(b10 >> 18) + alpha.charAt((b10 >> 12) & 0x3F) + 
       alpha.charAt((b10 >> 6) & 0x3f) + padchar); 
     break; 
    } 
    return x.join(''); 
} 
+0

come usare questo js per iframe src. –

+0

Questa libreria non è affidabile in alcuni casi, ad esempio, è panico per questa stringa: eyJhY3QiOiJpZG0sZmFjZWJvb2siLCJjb21maXJtZWQiOmZhbHNlLCJleHAiOjE0NTcwMDAwNjYsInN1YiI6ImJvbS5kLnZhbkBnbWFpbC5jb20ifQ – Van

+0

Consigliare questa libreria: http://kjur.github.io/jsrsasign/ o utilizzare questo uno direttamente: http: // kjur.github.io/jsrsasign/api/symbols/src/base64x-1.1.js.html – Van

7

atob e btoa sono funzioni specifiche mozilla seguito il supporto è stato esteso al browser webkit come chrome, safari quindi non funziona in IE.

Quindi meglio usare altre funzioni come: -

/** 
* 
* Base64 encode/decode 
* http://www.webtoolkit.info/ 
* 
**/ 

var Base64 = { 

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

    // 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(/\r\n/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; 
    } 

} 

questo risolverà il problema

+0

Questo non funziona se la mia stringa di input ha il simbolo pipe (|) che deve essere codificato. Chrome e IE danno risultati codificati diversi per questo input String with pipe. –

+2

@ Kanagavelu Sugumar, hai risolto il problema? –

+2

__ @ Kanagavelu Sugumar__, hai risolto il problema? – Redsandro