Déterminer si la chaîne est en base64 en utilisant JavaScript

Je suis en utilisant le window.atob('string') fonction de décoder une chaîne base64 pour une chaîne de caractères. Maintenant je me demande, est-il un moyen de vérifier que la "chaîne" est en fait valable base64? Je souhaite être informé si la chaîne n'est pas en base64 afin que je puisse effectuer une action différente.

source d'informationauteur Jonatan

  1. 10

    Si "valide" signifie "seulement a base64 caractères", puis la case contre [A-Za-z0-9+/=].

    Si "valide" signifie un "juridique" chaîne base64, alors vous devriez vérifier la = à la fin.

    Si "valide" signifie que c'est quelque chose de raisonnable après décodage puis elle nécessite la connaissance du domaine.

  2. 33

    Si vous voulez vérifier si elle peut être décodé ou pas, vous pouvez simplement essayer de les décoder et de voir si elle a échoué:

    try {
    window.atob(str);
} catch(e) {
    //something failed

    //if you want to be specific and only catch the error which means
    //the base 64 was invalid, then check for 'e.code === 5'.
    //(because 'DOMException.INVALID_CHARACTER_ERR === 5')
}
  3. 15

    Cela devrait faire l'affaire.

    function isBase64(str) {
    try {
        return btoa(atob(str)) == str;
    } catch (err) {
        return false;
    }
}
  4. 13

    Je voudrais utiliser une expression régulière pour que. Essayez celui-ci:

    /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/

    Explication:

    ^                          # Start of input
([0-9a-zA-Z+/]{4})*        # Groups of 4 valid characters decode
                           # to 24 bits of data for each group
(                          # Either ending with:
    ([0-9a-zA-Z+/]{2}==)   # two valid characters followed by ==
    |                      # , or
    ([0-9a-zA-Z+/]{3}=)    # three valid characters followed by =
)?                         # , or nothing
$                          # End of input
  5. 10

    Bâtiment sur @atornblad réponse, en utilisant les regex pour faire un simple test vrai ou faux de validité base64 est aussi facile comme suit:

    var base64regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;

base64regex.test("SomeStringObviouslyNotBase64Encoded...");             //FALSE
base64regex.test("U29tZVN0cmluZ09idmlvdXNseU5vdEJhc2U2NEVuY29kZWQ=");   //TRUE
  6. 2

    Cette méthode tente de décoder puis de coder et de les comparer à l'original. Pourrait également être combinée avec les autres réponses pour les environnements de jeter sur l'analyse des erreurs. Il est aussi possible d'avoir une chaîne qui ressemble valide base64 à partir d'une expression régulière point de vue, mais n'est pas réel, base64.

    if(btoa(atob(str))==str){
  //...
}
  7. 1

    C'est la façon dont c'est fait dans un de mes préférés de validation libs:

    const notBase64 = /[^A-Z0-9+\/=]/i;

export default function isBase64(str) {
  assertString(str); //remove this line and make sure you pass in a string
  const len = str.length;
  if (!len || len % 4 !== 0 || notBase64.test(str)) {
    return false;
  }
  const firstPaddingChar = str.indexOf('=');
  return firstPaddingChar === -1 ||
    firstPaddingChar === len - 1 ||
    (firstPaddingChar === len - 2 && str[len - 1] === '=');
}

    https://github.com/chriso/validator.js/blob/master/src/lib/isBase64.js

  8. 0

    Comme il y a principalement deux possibilités posté ici (regex vs try catch) je n'ai comparer la performance de deux:
    https://jsperf.com/base64-check/

    Regex solution semble être beaucoup plus rapide et gagnant.
    Vous ne savez pas si la regex captures tous les cas, mais pour mes tests, cela a fonctionné parfaitement.

    Grâce à @Philzen pour les regex!

    p.s.

    Au cas où quelqu'un est intéressé à trouver le moyen le plus rapide, en toute sécurité décodage en base64 chaîne (c'est comment je suis arrivé ici):
    https://jsperf.com/base64-decoding-check