Come si fa a rilevare il tipo di carta di Credito a base di numero?

Sto cercando di capire come identificare il tipo di carta di credito basato puramente sul suo numero. Qualcuno sa di una definitiva e affidabile per trovare questo?

  • Utilizzando un’espressione regolare. Check out questo link per ulteriori informazioni.
  • Questo articolo di wikipedia può essere utile nella vostra ricerca: Numeri di Carta di Credito sembra Che ci sono alcuni prefissi standard che vengono utilizzati, che potrebbero determinare il tipo di carta.
  • I dettagli sono tutti su Wikipedia: en.wikipedia.org/wiki/Credit_card_numbers
  • C’è una buona tabella di sintesi in Wikipedia, en.wikipedia.org/wiki/Credit_card_numbers. E ‘ il primo di sei cifre che indicano il tipo e l’emittente della carta.
  • Non vorrei usare una regex altro che tirare fuori il primo numerico del gruppo di, di solito si può dire solo da primi 4 numeri (in USA). Anche prima di preoccuparsi di pagare per la cancellazione di una carica di eseguire un Mod 10 checksum sul numero di carta per assicurarsi che potrebbe essere legittimo. algoritmo di Luhn
  • inoltre, chiunque può commentare se questi algoritmi sono per tutti o non cambiano periodicamente, come ad esempio l’algoritmo per il calcolo se è un numero di telefono in california”
  • Considera che molti siti web e applicazioni l’uso di questi valori, in modo che se dovessero cambiare sarebbe rovinare un sacco di sistemi.
  • Se stai cercando una buona soluzione di Javascript, qui: evolt.org/node/24700
  • più stabile trovate qui: edu.masoomyf.com/2018/07/…

 

26 Replies
  1. 720

    Il numero di carta di credito è definito come un PAN, o Primaria Numero di Conto. Le prime sei cifre del PAN sono presi dal IIN, o Emittente Numero di Identificazione, appartenenti alla banca emittente (IINs sono stati precedentemente noto come BIN — Banca di Identificazione Numeri — così si può vedere che i riferimenti a tale terminologia in alcuni documenti). Questi sei cifre sono soggetti ad uno standard internazionale, ISO/IEC 7812, e può essere utilizzato per determinare il tipo di scheda da parte del numero.

    Purtroppo l’attuale ISO/IEC 7812 database non è disponibile pubblicamente, tuttavia, ci sono ufficiali le liste, sia a pagamento che gratuite, tra cui su Wikipedia.

    Comunque, per rilevare il tipo di numero, è possibile utilizzare un’espressione regolare, come quelli di seguito: Di credito per le espressioni originali

    Visto: ^4[0-9]{6,}$ Visto i numeri di carta di iniziare con un 4.

    MasterCard: ^5[1-5][0-9]{5,}|222[1-9][0-9]{3,}|22[3-9][0-9]{4,}|2[3-6][0-9]{5,}|27[01][0-9]{4,}|2720[0-9]{3,}$ Prima del 2016, MasterCard numeri iniziano con i numeri da 51 a 55, ma solo rilevare MasterCard carte di credito; ci sono altre carte emesse utilizzando il sistema MasterCard che non rientrano in questa IIN gamma. Nel 2016, sarà aggiungere numeri nell’intervallo (222100-272099).

    American Express: ^3[47][0-9]{5,}$ American Express i numeri di carta di iniziare con il 34 o 37.

    Diners Club: ^3(?:0[0-5]|[68][0-9])[0-9]{4,}$ Diners Club, numeri di carta di iniziare con 300 fino a 305, 36 o 38. Ci sono le carte Diners Club che iniziano con 5 e dispone di 16 cifre. Questi sono di una joint venture tra Diners Club e MasterCard e dovrebbero essere trattati come una carta di credito MasterCard.

    Scoprire: ^6(?:011|5[0-9]{2})[0-9]{3,}$ Scoprire i numeri di carta di iniziare con 6011 o 65.

    JCB: ^(?:2131|1800|35[0-9]{3})[0-9]{3,}$ JCB cards iniziare con 2131, 1800 o 35.

    Purtroppo, ci sono un certo numero di tipi di carta trattati con il sistema MasterCard che non vivono nei MasterCard i IN range (a partire dal numero 51…55); il caso più importante è quello delle carte Maestro, molti dei quali sono stati emessi da altre banche gamme IIN e quindi si trovano in tutto lo spazio del numero. Come risultato, può essere meglio assumere che qualsiasi carta che non è di qualche altro tipo si accettano deve essere una carta di credito MasterCard.

    Importante: numeri di carta variano in lunghezza; come, per esempio, ha Visto, in passato, carte emesse con 13 cifre Pentole e carte con 16 cifre Padelle. Visto la documentazione attualmente indica che può problema o può avere emesso numeri, tra il 12 e il 19 cifre. Pertanto, si dovrebbe verificare la lunghezza del numero di carta, oltre a verificare che abbia almeno 7 cifre (per una completa IIN più una cifra di controllo, che deve corrispondere al valore previsto dal l’algoritmo di Luhn).

    Un ulteriore suggerimento: prima dell’elaborazione di un titolare di PAN, striscia di eventuali spazi e caratteri di punteggiatura da ingresso. Perché? Perché è in genere molto più facile per immettere le cifre in gruppi, in modo simile a come vengono visualizzate sulla parte anteriore di una vera carta di credito, vale a dire

    4444 4444 4444 4444
    

    è molto più facile per entrare correttamente di

    4444444444444444
    

    Non c’è davvero alcun beneficio nel castigare l’utente perché non hai inserito caratteri non si aspettano qui.

    Questo implica anche assicurarsi che la vostra voce campi di camera per almeno 24 caratteri, altrimenti gli utenti che entrano in spazi per correre fuori dalla stanza. Mi consiglia di rendere il campo abbastanza ampio per display a 32 caratteri e di consentire fino a 64, che dà un sacco di spazio per l’espansione.

    Ecco un’immagine che dà un po ‘ più comprensione:

    AGGIORNAMENTO (2014): Il checksum metodo non sembra più essere un valido strumento di verifica di una carta autenticità come indicato nei commenti su questa risposta.

    AGGIORNAMENTO (2016): Mastercard è quello di implementare il nuovo BIN intervalli di partenza Ach Pagamento.

    Come si fa a rilevare il tipo di carta di Credito a base di numero?

    • grande esempio. hai l’espressione regolare per carte maestro?
    • NO, NO, NO. Non si può fare affidamento sulle lunghezze dei numeri di carta; essi possono cambiare in qualsiasi momento. L’unica parte del numero della carta si può contare su è IIN (che ha usato per essere chiamato un BIDONE) e che è un prefisso del numero. Inoltre, è non rileva le carte Mastercard in modo che ti proponiamo, che sarà solo prendere un sottoinsieme delle carte che vengono elaborati tramite il sistema Mastercard (il problema più carte Maestro, che hanno una varietà di IIN prefissi).
    • hai letto le espressioni prima di commentare? Sono stati scritti appositamente per l’uso in IIN, quindi non capisco cosa stai cercando di dire. Inoltre, IIN può essere utilizzato per identificare l’emittente della carta, ma non convalidare. 5412, per esempio, non rappresentano un completo MasterCard, ma il tuo suggerimento implicherebbe che. Non ho trovato alcuna prova che Mastercard sono tutt’altro che a 16 cifre. Per favore, sentitevi liberi di fornire una fonte per il vostro reclamo. Lei ha ragione nel ricordare che un aggiornamento deve essere fatto per le carte Maestro, tuttavia.
    • da quanto ho capito, il numero di 10 cifre stampate su carte Maestro non l’attuale Maestro il numero di carta. Da quello che ho capito (correggimi se sbaglio), il 19 cifre Maestro il numero della carta non è da nessuna parte sulla carta (per motivi di sicurezza).
    • Hai ragione, 5412 non sarebbe completo Mastercard numero. IINs sono sei cifre, in modo completo il numero della carta deve essere di 7 cifre (minimo) e che deve superare il Luhn di controllo. Non c’è bisogno di “prove” Mastercard numeri hanno qualcosa di diverso da 16 cifre; il punto è che, a prescindere dalla situazione di oggi, in futuro potrebbero emettere carte di 17 o 18 cifre, o per quella materia, alcune con 15. Contare su di loro è di 16 cifre è inutile e crea un mantenimento a lungo termine del rischio.
    • Per quanto riguarda il Maestro, la cosa che gli utenti di immettere sul tuo sito web è il numero stampato sul fronte della carta. Ci possono essere altri numeri associati, ma tuttavia il numero sulla faccia di una carta Maestro può venire da un certo numero di diverse gamme di fuori di Mastercard di solito gamme IIN. La cosa più sicura da fare IMO è per quanto riguarda le carte Mastercard, salvo prova contraria, e di concentrarsi su di rilevare gli altri tipi di carta.
    • E sì, ho letto le espressioni regolari; la principale caratteristica deplorevole è inutile lunghezza controlli. Secondario è la Mastercard/Maestro problema.
    • Ho presentato alcune modifiche per correggere i problemi che ho evidenziato e anche di aggiungere alcune ulteriori osservazioni che la gente potrebbe trovare utile.
    • Io rispettosamente in disaccordo con le modifiche al numero di cifre. A proposito MasterCard, ho documentazione specificamente per MasterCard, specificando che, per essere valido Mastercard sono 16 cifre, che è il motivo per cui ho chiesto di fornire ulteriori informazioni. Mentre si potrebbe cambiare in futuro, è molto più probabile che qualcuno si immette un numero non valido di cifre, che causano la transazione negata. Non voglio che i miei utenti per colpire un ipotetico pulsante “Invia” se hai, per esempio, è entrato solo 15 cifre.
    • Siete preoccuparsi di nulla. La possibilità che l’utente eliminazione di una cifra o due e ancora passando il Luhn di controllo sono molto piccole. Tuttavia, se si limita il numero di cifre inutilmente, si potrebbe scoprire che alcune persone non riescono a pagare (che potrebbe anche essere vero, attualmente, per alcuni clienti Visa, per esempio, a causa della lunghezza dei controlli).
    • Venendo con una espressione per carte Maestro è difficile perché sono diffuse in tutto l’intervallo di numeri. È più facile determinare l’esclusione — cioè, se non è uno degli altri, si supponga che è Maestro.
    • Ho usato questa espressione regolare per carte Maestro e funziona benissimo. ^(5[06-8]|6[0-9])[0-9x]{10,17}$
    • Così come lungo come si capisce che la regex che prende una pila di carte che non sono carte Maestro a tutti (ad esempio, Scoprire le carte di credito, un paio di specializzazione MasterCard credito a carte, varie carte BANCOMAT e carte bancomat, China UnionPay carte, per non parlare di un intero carico di lealtà e/o memorizzare le carte che non possono essere usate come carte di credito o bancomat presso tutti).
    • Penso che questo non è più valido (la convalida di parte). Ho trovato 58 su una sola carta, e 124, dall’altro. Sono stato con loro per così tanto tempo (più di 2 anni)
    • Idem su quello. Entrambe le mie carte (anche se ristampato di recente) hanno valori di checksum non divisibile per 10.
    • che tipo di carta?
    • una VISA e una MasterCard.
    • Io il check-in quando ho un momento, ma se vi capita di conoscere un nuovo metodo, sentitevi liberi di fare una modifica.
    • checksum deve essere divisibile per 5
    • Trovo molto difficile credere che alcuni validi schede non hanno una corretta cifra di controllo secondo l’algoritmo di Luhn. Esso è utilizzato in modo assolutamente ovunque per controllare i numeri di carta di contro errori semplici e stupidi tentativi di frode. Invece ho notato che alcune persone intelligenti semplicemente non afferrare l’algoritmo, e hanno appena calcolare sbagliato.
    • href=”https://en.wikipedia.org/wiki/Luhn_algorithm” >algoritmo di LUHN non richiede che il numero sia divisibile per 10 (o un qualsiasi numero particolare), semplicemente si applica una formula per generare un valore che le cifre poi guarda l’ultima cifra del valore (utilizza %10, non a /10). E ‘ utilizzato da carta.
    • Buon commento sui numeri e intervalli, cambiano di volta in volta. MasterCard presenterà una nuova gamma nel mese di ottobre del 2016, meglio a sperare che non si dispone di uno come probabilmente fallirà la validazione su molti siti web.
    • Importante notare che, anche se di MasterCard non può cadere tra 51 e 55, Qualsiasi carta di credito a partire con un 5 è, infatti, una carta di credito MasterCard.
    • scoprire i numeri sono: 6011, 622126-622925, 644-649, 65 regexp:^6011[0-9]|65[0-9]|64[4-9][0-9]|62212[6-9][0-9]|6221[3-9][0-9]|622[2-9][0-9]|6229[01][0-9]|62292[0-5][0-9]{6,}$
    • diners numeri sono: 300-305, 309, 36, 38-39 regexp: ^3(?:0[0-59]|[689][0-9])[0-9]{4,}$
    • Ho una carta di credito che consente di aggiungere fino a 74
    • AmEx iniziare con 34 e 37. ma quando ho aggiunto questo numero di test 378282246310005 la mia funzione JS dice che non è valido il numero, ma quando ho aggiunto nella mia funzione js prefisso 341 o 378 poi il suo lavoro, cosa è il problema?
    • Non dovrebbe espressioni regolari sempre “inizia con” loro “o” clausole? Attualmente quando controllo “378282246310005” (che è AmericanExpress) la carta viene un match contro MasterCard regex, troppo. La correzione potrebbe essere quello di cambiare MasterCard regex to”^5[1-5][0-9]{5,}|^222[1-9][0-9]{3,}|^22[3-9][0-9]{4,}|^2[3-6][0-9]{5,}|^27[01][0-9]{4,}|^2720[0-9]{3,}$”
    • che guarda a destra. Non ho testato, ma sentitevi liberi di fare la correzione, se sei sicuro che funziona correttamente. Dubito che arriveremo fino a questo fine settimana, ma se ci penso, io dopo alcuni test unitari di GitHub con valido mock numeri di carta di credito per i test. Penso sarebbe una bella aggiunta a questo post.
    • Mastercard RegEx non è preciso qui e farà di falsi positivi partite (ad esempio 424242424242 visto il numero di partite in regex qui: ^5[1-5][0-9]{5,}|222[1-9][0-9]{3,}|22[3-9][0-9]{4,}|2[3-6][0-9]{5,}|27[01][0-9]{4,}|2720[0-9]{3,}$ Utilizzare @janos-szabo regex, invece, si impone una prima serie di 5 o 2: ^(5[1-5]|222[1-9]|22[3-9]|2[3-6]|27[01]|2720)[0-9]{0,}$
    • documento indica la Scoperta di regex ha bisogno di essere aggiornati per includere un sacco di nuove gamme.
    • Questa espressione regolare aderisce strettamente alle regole nel citato documento. Può essere facilmente modificato per controllare solo IINs.
    • Vorrei solo notare che, mentre la mastercard regex opere. tecnicamente sta facendo più di quanto si deve. Secondo mastercard: “Account primario è il numero di conto (PAN) che inizia con un BIN nella gamma di 222100 per 272099 o 510000 per 559999.” Quindi non si ha realmente bisogno di controllare indietro di 6 cifre. Così ho messo insieme questa regex: “^(5[1-5][0-9]{2}|222[1-9]|2[3-6][0-9]{2}|27[0-1][0-9]|2720)[0-9]{2,}$”
    • queste espressioni non riuscire per il numero di carta di 378282246310005. questo numero non ha superato il test di entrambi, MasterCard e Amex

  2. 69

    In javascript:

    function detectCardType(number) {
        var re = {
            electron: /^(4026|417500|4405|4508|4844|4913|4917)\d+$/,
            maestro: /^(5018|5020|5038|5612|5893|6304|6759|6761|6762|6763|0604|6390)\d+$/,
            dankort: /^(5019)\d+$/,
            interpayment: /^(636)\d+$/,
            unionpay: /^(62|88)\d+$/,
            visa: /^4[0-9]{12}(?:[0-9]{3})?$/,
            mastercard: /^5[1-5][0-9]{14}$/,
            amex: /^3[47][0-9]{13}$/,
            diners: /^3(?:0[0-5]|[68][0-9])[0-9]{11}$/,
            discover: /^6(?:011|5[0-9]{2})[0-9]{12}$/,
            jcb: /^(?:2131|1800|35\d{3})\d{11}$/
        }
    
        for(var key in re) {
            if(re[key].test(number)) {
                return key
            }
        }
    }

    Unit test:

    describe('CreditCard', function() {
        describe('#detectCardType', function() {
    
            var cards = {
                '8800000000000000': 'UNIONPAY',
    
                '4026000000000000': 'ELECTRON',
                '4175000000000000': 'ELECTRON',
                '4405000000000000': 'ELECTRON',
                '4508000000000000': 'ELECTRON',
                '4844000000000000': 'ELECTRON',
                '4913000000000000': 'ELECTRON',
                '4917000000000000': 'ELECTRON',
    
                '5019000000000000': 'DANKORT',
    
                '5018000000000000': 'MAESTRO',
                '5020000000000000': 'MAESTRO',
                '5038000000000000': 'MAESTRO',
                '5612000000000000': 'MAESTRO',
                '5893000000000000': 'MAESTRO',
                '6304000000000000': 'MAESTRO',
                '6759000000000000': 'MAESTRO',
                '6761000000000000': 'MAESTRO',
                '6762000000000000': 'MAESTRO',
                '6763000000000000': 'MAESTRO',
                '0604000000000000': 'MAESTRO',
                '6390000000000000': 'MAESTRO',
    
                '3528000000000000': 'JCB',
                '3589000000000000': 'JCB',
                '3529000000000000': 'JCB',
    
                '6360000000000000': 'INTERPAYMENT',
    
                '4916338506082832': 'VISA',
                '4556015886206505': 'VISA',
                '4539048040151731': 'VISA',
                '4024007198964305': 'VISA',
                '4716175187624512': 'VISA',
    
                '5280934283171080': 'MASTERCARD',
                '5456060454627409': 'MASTERCARD',
                '5331113404316994': 'MASTERCARD',
                '5259474113320034': 'MASTERCARD',
                '5442179619690834': 'MASTERCARD',
    
                '6011894492395579': 'DISCOVER',
                '6011388644154687': 'DISCOVER',
                '6011880085013612': 'DISCOVER',
                '6011652795433988': 'DISCOVER',
                '6011375973328347': 'DISCOVER',
    
                '345936346788903': 'AMEX',
                '377669501013152': 'AMEX',
                '373083634595479': 'AMEX',
                '370710819865268': 'AMEX',
                '371095063560404': 'AMEX'
            };
    
            Object.keys(cards).forEach(function(number) {
                it('should detect card ' + number + ' as ' + cards[number], function() {
                    Basket.detectCardType(number).should.equal(cards[number]);
                });
            });
        });
    });
    • Test di violino creata qui jsfiddle.net/ipsjolly/9whmL9u0
    • Il tuo violino restituisce undefined per tutti i test. Non funziona 🙁
    • basta inserire un valore ad esempio. 372176090165471 per AMAX nel campo di testo
    • Vedo… speravo in qualcosa che avrebbe formato I tipo (off l’evento keyup). Il violino funziona quando devo inserire un numero intero.
    • Ho finito di scrivere questo pezzo di codice per fare l’ingresso di formattazione e di convalida che volevo. quercusv.github.io/smartForm
    • sapete come si rileva v-pay e bancontact numeri? Grazie
    • Il mio Maestro di iniziare con 6757…

  3. 32

    Aggiornamento: 15 giugno 2016 (come ultima soluzione attualmente)

    Si prega di notare che ho anche dare un voto per quello che è il top votato, ma per mettere in chiaro queste sono le espressioni effettivamente funziona l’ho testato con migliaia di reale RACCOGLITORE di codici. Il più importante è quello di iniziare a utilizzare corde (^) altrimenti sarà dare risultati falsi nel mondo reale!

    JCB ^(?:2131|1800|35)[0-9]{0,}$ Iniziare con: 2131, 1800, 35 (3528-3589)

    American Express ^3[47][0-9]{0,}$ iniziano con: 34, 37

    Diners Club ^3(?:0[0-59]{1}|[689])[0-9]{0,}$ Iniziare con: 300-305, 309, 36, 38-39

    Visto ^4[0-9]{0,}$ iniziano con: 4

    MasterCard ^(5[1-5]|222[1-9]|22[3-9]|2[3-6]|27[01]|2720)[0-9]{0,}$ iniziano con: 2221-2720, 51-55

    Maestro ^(5[06789]|6)[0-9]{0,}$ Maestro sempre crescente nell’intervallo: 60-69, iniziato con /e non qualcos’altro, ma a partire da 5 deve essere codificato come mastercard comunque. Maestro carte di credito devono essere rilevati alla fine del codice in quanto alcuni altri, è nel range di 60-69. Si prega di guardare il codice.

    Scoprire ^(6011|65|64[4-9]|62212[6-9]|6221[3-9]|622[2-8]|6229[01]|62292[0-5])[0-9]{0,}$ Scoprire molto difficile da codice, iniziare con: 6011, 622126-622925, 644-649, 65

    In javascript io uso questa funzione. Questo è un bene quando u assegnarlo a un evento onkeyup e dare un risultato più presto possibile.

    function cc_brand_id(cur_val) {
      //the regular expressions check for possible matches as you type, hence the OR operators based on the number of chars
      //regexp string length {0} provided for soonest detection of beginning of the card numbers this way it could be used for BIN CODE detection also
    
      //JCB
      jcb_regex = new RegExp('^(?:2131|1800|35)[0-9]{0,}$'); //2131, 1800, 35 (3528-3589)
      //American Express
      amex_regex = new RegExp('^3[47][0-9]{0,}$'); //34, 37
      //Diners Club
      diners_regex = new RegExp('^3(?:0[0-59]{1}|[689])[0-9]{0,}$'); //300-305, 309, 36, 38-39
      //Visa
      visa_regex = new RegExp('^4[0-9]{0,}$'); //4
      //MasterCard
      mastercard_regex = new RegExp('^(5[1-5]|222[1-9]|22[3-9]|2[3-6]|27[01]|2720)[0-9]{0,}$'); //2221-2720, 51-55
      maestro_regex = new RegExp('^(5[06789]|6)[0-9]{0,}$'); //always growing in the range: 60-69, started with /not something else, but starting 5 must be encoded as mastercard anyway
      //Discover
      discover_regex = new RegExp('^(6011|65|64[4-9]|62212[6-9]|6221[3-9]|622[2-8]|6229[01]|62292[0-5])[0-9]{0,}$');
      ////6011, 622126-622925, 644-649, 65
    
    
      //get rid of anything but numbers
      cur_val = cur_val.replace(/\D/g, '');
    
      //checks per each, as their could be multiple hits
      //fix: ordering matter in detection, otherwise can give false results in rare cases
      var sel_brand = "unknown";
      if (cur_val.match(jcb_regex)) {
        sel_brand = "jcb";
      } else if (cur_val.match(amex_regex)) {
        sel_brand = "amex";
      } else if (cur_val.match(diners_regex)) {
        sel_brand = "diners_club";
      } else if (cur_val.match(visa_regex)) {
        sel_brand = "visa";
      } else if (cur_val.match(mastercard_regex)) {
        sel_brand = "mastercard";
      } else if (cur_val.match(discover_regex)) {
        sel_brand = "discover";
      } else if (cur_val.match(maestro_regex)) {
        if (cur_val[0] == '5') { //started 5 must be mastercard
          sel_brand = "mastercard";
        } else {
          sel_brand = "maestro"; //maestro is all 60-69 which is not something else, thats why this condition in the end
        }
      }
    
      return sel_brand;
    }
    

    Qui si può giocare con essa:

    http://jsfiddle.net/upN3L/69/

    Per PHP utilizzare questa funzione, questo rileva alcuni sub VISA/MC schede di troppo:

        /**
     * Obtain a brand constant from a PAN 
     *
     * @param type $pan               Credit card number
     * @param type $include_sub_types Include detection of sub visa brands
     * @return string
     */
    public static function getCardBrand($pan, $include_sub_types = false)
    {
        //maximum length is not fixed now, there are growing number of CCs has more numbers in length, limiting can give false negatives atm
    
        //these regexps accept not whole cc numbers too
        //visa        
        $visa_regex = "/^4[0-9]{0,}$/";
        $vpreca_regex = "/^428485[0-9]{0,}$/";
        $postepay_regex = "/^(402360|402361|403035|417631|529948){0,}$/";
        $cartasi_regex = "/^(432917|432930|453998)[0-9]{0,}$/";
        $entropay_regex = "/^(406742|410162|431380|459061|533844|522093)[0-9]{0,}$/";
        $o2money_regex = "/^(422793|475743)[0-9]{0,}$/";
    
        //MasterCard
        $mastercard_regex = "/^(5[1-5]|222[1-9]|22[3-9]|2[3-6]|27[01]|2720)[0-9]{0,}$/";
        $maestro_regex = "/^(5[06789]|6)[0-9]{0,}$/"; 
        $kukuruza_regex = "/^525477[0-9]{0,}$/";
        $yunacard_regex = "/^541275[0-9]{0,}$/";
    
        //American Express
        $amex_regex = "/^3[47][0-9]{0,}$/";
    
        //Diners Club
        $diners_regex = "/^3(?:0[0-59]{1}|[689])[0-9]{0,}$/";
    
        //Discover
        $discover_regex = "/^(6011|65|64[4-9]|62212[6-9]|6221[3-9]|622[2-8]|6229[01]|62292[0-5])[0-9]{0,}$/";
    
        //JCB
        $jcb_regex = "/^(?:2131|1800|35)[0-9]{0,}$/";
    
        //ordering matter in detection, otherwise can give false results in rare cases
        if (preg_match($jcb_regex, $pan)) {
            return "jcb";
        }
    
        if (preg_match($amex_regex, $pan)) {
            return "amex";
        }
    
        if (preg_match($diners_regex, $pan)) {
            return "diners_club";
        }
    
        //sub visa/mastercard cards
        if ($include_sub_types) {
            if (preg_match($vpreca_regex, $pan)) {
                return "v-preca";
            }
            if (preg_match($postepay_regex, $pan)) {
                return "postepay";
            }
            if (preg_match($cartasi_regex, $pan)) {
                return "cartasi";
            }
            if (preg_match($entropay_regex, $pan)) {
                return "entropay";
            }
            if (preg_match($o2money_regex, $pan)) {
                return "o2money";
            }
            if (preg_match($kukuruza_regex, $pan)) {
                return "kukuruza";
            }
            if (preg_match($yunacard_regex, $pan)) {
                return "yunacard";
            }
        }
    
        if (preg_match($visa_regex, $pan)) {
            return "visa";
        }
    
        if (preg_match($mastercard_regex, $pan)) {
            return "mastercard";
        }
    
        if (preg_match($discover_regex, $pan)) {
            return "discover";
        }
    
        if (preg_match($maestro_regex, $pan)) {
            if ($pan[0] == '5') {//started 5 must be mastercard
                return "mastercard";
            }
                return "maestro"; //maestro is all 60-69 which is not something else, thats why this condition in the end
    
        }
    
        return "unknown"; //unknown for this system
    }
    
    • E si prega di notare che questo è solo CC individuazione del numero e non convalida. Che è separato, deve essere un Luhn controllare…
    • Dove è Visa Electron, e perché il Maestro check ritorno MasterCard in alcuni casi? Non la MasterCard di controllo che di per sé?
    • Non si riconosce in questo JCB numero di test come qualsiasi tipo (3088514174175777), e identifica questo test JCB numero diners_club (3096278649822922). Assumendo questo elenco di test di numeri di carta sono validi comunque (freeformatter.com/credit-card-number-generator-validator.html)
    • ci sono alcuna documentazione che, a partire 308 309 potrebbe essere un JCB card
    • +1 per la fornitura di cc di rilevamento del tipo di codice, che è quello che in genere si desidera fare per la ux – la regex per la nuova gamma MC ha bisogno di un piccolo tweek: /^(5[1-5]|222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{0,}$/
  4. 19
      public string GetCreditCardType(string CreditCardNumber)
        {
            Regex regVisa = new Regex("^4[0-9]{12}(?:[0-9]{3})?$");
            Regex regMaster = new Regex("^5[1-5][0-9]{14}$");
            Regex regExpress = new Regex("^3[47][0-9]{13}$");
            Regex regDiners = new Regex("^3(?:0[0-5]|[68][0-9])[0-9]{11}$");
            Regex regDiscover = new Regex("^6(?:011|5[0-9]{2})[0-9]{12}$");
            Regex regJCB= new Regex("^(?:2131|1800|35\\d{3})\\d{11}$");
    
    
            if(regVisa.IsMatch(CreditCardNumber))
                return "VISA";
           else if (regMaster.IsMatch(CreditCardNumber))
                return "MASTER";
          else  if (regExpress.IsMatch(CreditCardNumber))
                return "AEXPRESS";
           else if (regDiners.IsMatch(CreditCardNumber))
                return "DINERS";
           else if (regDiscover.IsMatch(CreditCardNumber))
                return "DISCOVERS";
           else   if (regJCB.IsMatch(CreditCardNumber))
                return "JCB";
           else
            return "invalid";
        }
    

    Qui è la funzione per controllare il tipo di carta di Credito tramite Regex , c#

  5. 18

    Controllare questo fuori:

    http://www.breakingpar.com/bkp/home.nsf/0/87256B280015193F87256CC70060A01B

    function isValidCreditCard(type, ccnum) {
    /* Visa: length 16, prefix 4, dashes optional.
    Mastercard: length 16, prefix 51-55, dashes optional.
    Discover: length 16, prefix 6011, dashes optional.
    American Express: length 15, prefix 34 or 37.
    Diners: length 14, prefix 30, 36, or 38. */
    
      var re = new Regex({ "visa": "/^4\d{3}-?\d{4}-?\d{4}-?\d",
                           "mc": "/^5[1-5]\d{2}-?\d{4}-?\d{4}-?\d{4}$/",
                           "disc": "/^6011-?\d{4}-?\d{4}-?\d{4}$/",
                           "amex": "/^3[47]\d{13}$/",
                           "diners": "/^3[068]\d{12}$/"}[type.toLowerCase()])
    
       if (!re.test(ccnum)) return false;
       //Remove all dashes for the checksum checks to eliminate negative numbers
       ccnum = ccnum.split("-").join("");
       //Checksum ("Mod 10")
       //Add even digits in even length strings or odd digits in odd length strings.
       var checksum = 0;
       for (var i=(2-(ccnum.length % 2)); i<=ccnum.length; i+=2) {
          checksum += parseInt(ccnum.charAt(i-1));
       }
       //Analyze odd digits in even length strings or even digits in odd length strings.
       for (var i=(ccnum.length % 2) + 1; i<ccnum.length; i+=2) {
          var digit = parseInt(ccnum.charAt(i-1)) * 2;
          if (digit < 10) { checksum += digit; } else { checksum += (digit-9); }
       }
       if ((checksum % 10) == 0) return true; else return false;
    }
    
  6. 12

    Ecco Completo di C# o VB codice per tutti i tipi di CC cose correlate su codeproject.

    • IsValidNumber
    • GetCardTypeFromNumber
    • GetCardTestNumber
    • PassesLuhnTest

    Questo articolo è stato per un paio di anni senza commenti negativi.

    • risolto. guarda come l’hanno spostato da ‘aspnet’ categoria ‘convalida’ la categoria che ha cambiato il link
    • Link è rotto. Forse questo è l’utilità stessa? codeproject.com/Articles/20271/…
    • Che codeproject codice è dal 2007. Attenzione, Non possono essere obsoleti.
  7. 12

    recentemente ho bisogno di queste funzionalità, sono stato il porting del Framework Zend Carta di Credito Validatore per ruby.
    rubino: https://github.com/Fivell/credit_card_validations
    zend framework: https://github.com/zendframework/zf2/blob/master/library/Zend/Validator/CreditCard.php

    Entrambi INN varia per la rilevazione di tipo. Qui potete leggere circa INN

    In base a questo è possibile rilevare la carta di credito in alternativa (senza espressioni,ma che dichiara alcune regole sui prefissi e lunghezza)

    Così abbiamo accanto norme per la maggior parte delle schede usate

    ########  most used brands #########
    
        visa: [
            {length: [13, 16], prefixes: ['4']}
        ],
        mastercard: [
            {length: [16], prefixes: ['51', '52', '53', '54', '55']}
        ],
    
        amex: [
            {length: [15], prefixes: ['34', '37']}
        ],
        ######## other brands ########
        diners: [
            {length: [14], prefixes: ['300', '301', '302', '303', '304', '305', '36', '38']},
        ],
    
        #There are Diners Club (North America) cards that begin with 5. These are a joint venture between Diners Club and MasterCard, and are processed like a MasterCard
        # will be removed in next major version
    
        diners_us: [
            {length: [16], prefixes: ['54', '55']}
        ],
    
        discover: [
            {length: [16], prefixes: ['6011', '644', '645', '646', '647', '648',
                                      '649', '65']}
        ],
    
        jcb: [
            {length: [16], prefixes: ['3528', '3529', '353', '354', '355', '356', '357', '358', '1800', '2131']}
        ],
    
    
        laser: [
            {length: [16, 17, 18, 19], prefixes: ['6304', '6706', '6771']}
        ],
    
        solo: [
            {length: [16, 18, 19], prefixes: ['6334', '6767']}
        ],
    
        switch: [
            {length: [16, 18, 19], prefixes: ['633110', '633312', '633304', '633303', '633301', '633300']}
    
        ],
    
        maestro: [
            {length: [12, 13, 14, 15, 16, 17, 18, 19], prefixes: ['5010', '5011', '5012', '5013', '5014', '5015', '5016', '5017', '5018',
                                                                  '502', '503', '504', '505', '506', '507', '508',
                                                                  '6012', '6013', '6014', '6015', '6016', '6017', '6018', '6019',
                                                                  '602', '603', '604', '605', '6060',
                                                                  '677', '675', '674', '673', '672', '671', '670',
                                                                  '6760', '6761', '6762', '6763', '6764', '6765', '6766', '6768', '6769']}
        ],
    
        # Luhn validation are skipped for union pay cards because they have unknown generation algoritm
        unionpay: [
            {length: [16, 17, 18, 19], prefixes: ['622', '624', '625', '626', '628'], skip_luhn: true}
        ],
    
        dankrot: [
            {length: [16], prefixes: ['5019']}
        ],
    
        rupay: [
            {length: [16], prefixes: ['6061', '6062', '6063', '6064', '6065', '6066', '6067', '6068', '6069', '607', '608'], skip_luhn: true}
        ]
    
    }
    

    Poi cercando prefisso e il confronto di lunghezza è possibile rilevare la carta di credito marca. Inoltre, non dimenticare di luhn algoritm (è descritta qui http://en.wikipedia.org/wiki/Luhn).

    • Illustrativo. Le carte VISA potrebbe essere di 13 cifre.
    • nessun VISTO il sito dice che dovrebbe essere di 16 lunghezza, penso che molto tempo fa poteva essere 13, ma non oggi
    • Beh, almeno PayPal accetta VISA 4222222222222 in modalità di test (developer.paypal.com/docs/classic/payflow/integration-guide/…), in modo che questo dipende dal fatto che il codice sia per il lavoro sia in live e modalità di prova.
    • Penso che sia il supporto legacy
    • c’è una cosa in più, VISTO VPay carte e quale a wikipedia della Visa, VPay marchio è in grado di specificare PAN lunghezze dal 13 al 19 cifre di un numero di carta di più di 16 cifre sono già evidenti.
    • Questo esempio sarebbe molto meglio con una routine che mostra come utilizzare i dati.
    • È il RuPay IIN/BIN formalmente messo da qualche parte? A quanto ho capito, è in crescita, quindi una buona fonte può essere sfruttato per futuri aggiornamenti. (Ho cercato su google, ma non ho trovato, sarà lieto se è possibile condividere la vostra fonte).

  8. 7

    Compatto versione javascript

        var getCardType = function (number) {
            var cards = {
                visa: /^4[0-9]{12}(?:[0-9]{3})?$/,
                mastercard: /^5[1-5][0-9]{14}$/,
                amex: /^3[47][0-9]{13}$/,
                diners: /^3(?:0[0-5]|[68][0-9])[0-9]{11}$/,
                discover: /^6(?:011|5[0-9]{2})[0-9]{12}$/,
                jcb: /^(?:2131|1800|35\d{3})\d{11}$/
            };
            for (var card in cards) {
                if (cards[card].test(number)) {
                    return card;
                }
            }
        };
    
  9. 7

    Anatoliy risposta in PHP:

     public static function detectCardType($num)
     {
        $re = array(
            "visa"       => "/^4[0-9]{12}(?:[0-9]{3})?$/",
            "mastercard" => "/^5[1-5][0-9]{14}$/",
            "amex"       => "/^3[47][0-9]{13}$/",
            "discover"   => "/^6(?:011|5[0-9]{2})[0-9]{12}$/",
        );
    
        if (preg_match($re['visa'],$num))
        {
            return 'visa';
        }
        else if (preg_match($re['mastercard'],$num))
        {
            return 'mastercard';
        }
        else if (preg_match($re['amex'],$num))
        {
            return 'amex';
        }
        else if (preg_match($re['discover'],$num))
        {
            return 'discover';
        }
        else
        {
            return false;
        }
     }
    
  10. 6

    Qui è una classe php funzione restituisce CCtype da CCnumber.

    In questo codice non convalida il biglietto o non viene eseguito l’algoritmo di Luhn solo cercare di trovare il tipo di carta di credito sulla base della tabella in questa pagina. fondamentalmente utilizza CCnumber lunghezza e CCcard prefisso per determinare CCcard tipo.

        <?php class CreditcardType
        {
       public static $creditcardTypes = array(
                array('Name'=>'American Express','cardLength'=>array(15),'cardPrefix'=>array('34', '37'))
                ,array('Name'=>'Maestro','cardLength'=>array(12, 13, 14, 15, 16, 17, 18, 19),'cardPrefix'=>array('5018', '5020', '5038', '6304', '6759', '6761', '6763'))
                ,array('Name'=>'Mastercard','cardLength'=>array(16),'cardPrefix'=>array('51', '52', '53', '54', '55'))
                ,array('Name'=>'Visa','cardLength'=>array(13,16),'cardPrefix'=>array('4'))
                ,array('Name'=>'JCB','cardLength'=>array(16),'cardPrefix'=>array('3528', '3529', '353', '354', '355', '356', '357', '358'))
                ,array('Name'=>'Discover','cardLength'=>array(16),'cardPrefix'=>array('6011', '622126', '622127', '622128', '622129', '62213',
                                            '62214', '62215', '62216', '62217', '62218', '62219',
                                            '6222', '6223', '6224', '6225', '6226', '6227', '6228',
                                            '62290', '62291', '622920', '622921', '622922', '622923',
                                            '622924', '622925', '644', '645', '646', '647', '648',
                                            '649', '65'))
                ,array('Name'=>'Solo','cardLength'=>array(16, 18, 19),'cardPrefix'=>array('6334', '6767'))
                ,array('Name'=>'Unionpay','cardLength'=>array(16, 17, 18, 19),'cardPrefix'=>array('622126', '622127', '622128', '622129', '62213', '62214',
                                            '62215', '62216', '62217', '62218', '62219', '6222', '6223',
                                            '6224', '6225', '6226', '6227', '6228', '62290', '62291',
                                            '622920', '622921', '622922', '622923', '622924', '622925'))
                ,array('Name'=>'Diners Club','cardLength'=>array(14),'cardPrefix'=>array('300', '301', '302', '303', '304', '305', '36'))
                ,array('Name'=>'Diners Club US','cardLength'=>array(16),'cardPrefix'=>array('54', '55'))
                ,array('Name'=>'Diners Club Carte Blanche','cardLength'=>array(14),'cardPrefix'=>array('300','305'))
                ,array('Name'=>'Laser','cardLength'=>array(16, 17, 18, 19),'cardPrefix'=>array('6304', '6706', '6771', '6709'))
        );     
            private function __construct() {}    
            public static function getType($CCNumber)
            {
                $CCNumber= trim($CCNumber);
                $type='Unknown';
                foreach (CreditcardType::$creditcardTypes as $card){
                    if (! in_array(strlen($CCNumber),$card['cardLength'])) {
                        continue;
                    }
                    $prefixes = '/^('.implode('|',$card['cardPrefix']).')/';            
                    if(preg_match($prefixes,$CCNumber) == 1 ){
                        $type= $card['Name'];
                        break;
                    }
                }
                return $type;
            }
        } ?>
    
  11. 5

    Non cercare di rilevare il tipo di carta di credito come parte di elaborazione di un pagamento. Si sta rischiando di declinare le transazioni valide.

    Se avete bisogno di fornire informazioni per il tuo processore di pagamento (ad esempio PayPal, carta di credito oggetto richiede il nome tipo di carta), quindi immagino non sia da meno informazioni disponibili, ad esempio,

    $credit_card['pan'] = preg_replace('/[^0-9]/', '', $credit_card['pan']);
    $inn = (int) mb_substr($credit_card['pan'], 0, 2);
    
    //@see http://en.wikipedia.org/wiki/List_of_Bank_Identification_Numbers#Overview
    if ($inn >= 40 && $inn <= 49) {
        $type = 'visa';
    } else if ($inn >= 51 && $inn <= 55) {
        $type = 'mastercard';
    } else if ($inn >= 60 && $inn <= 65) {
        $type = 'discover';
    } else if ($inn >= 34 && $inn <= 37) {
        $type = 'amex';
    } else {
        throw new \UnexpectedValueException('Unsupported card type.');
    }

    Questa implementazione (utilizzando solo le prime due cifre), è sufficiente per identificare tutti i principali (e in PayPal caso tutte le supportato) gli schemi di carte. In realtà, si potrebbe desiderare di saltare l’eccezione del tutto, e di default per il più popolare tipo di carta. Lasciate che il gateway di pagamento/processore di dirti se c’è un errore di convalida in risposta alla vostra richiesta.

    La realtà è che il gateway di pagamento non si cura circa il valore che forniscono.

    • Questo è semplicemente falso. So di 3 diversi fornitori di servizi che NON richiedono tipi di carta per essere passata, e se non passa, l’operazione avrà esito negativo.
    • non si cura di ciò che il valore di” non è la stessa come “non si preoccupa se il passato”.
    • Dove ho specificare? Ho semplicemente detto che ci sono fornitori di servizi in uso, che richiedono il passaggio di CC tipo, niente di più.
    • si può semplificare questo complesso problema, ma di solito i fornitori di servizi di pagamento non richiedono per proporvi il tipo di carta, hanno un proprio metodo per rilevare
  12. 5

    I primi numeri della carta di credito può essere utilizzato per stimare il fornitore di:

    • Visto: 49,44 o 47
    • Visa electron: 42, 45, 48, 49
    • MasterCard: 51
    • Amex:34
    • Diners: 30, 36, 38
    • JCB: 35
  13. 5

    In Carta di Riconoscimento (CRR), un inconveniente con algoritmi che utilizzano una serie di regex o altri hard-coded intervalli, è che i Bidoni/IINs fare a cambiare nel tempo, nella mia esperienza. Il co-branding di carte è in corso di complicanze. Scheda diversa Acquirenti /partner potrebbe essere necessario trattare la stessa scheda in modo diverso, a seconda ad esempio la geolocalizzazione.

    Inoltre, negli ultimi anni, ad esempio, non si accettano carte in una più ampia diffusione, i modelli esistenti non far fronte con nuove gamme di prodotti che a volte interleave con intervalli di più ampia che sostituisce.

    Conoscendo la geografia sistema ha bisogno di copertura può aiutare, come alcuni intervalli sono limitati a usare in determinati paesi. Per esempio, gli intervalli di 62 includere alcuni AAA sub-intervalli di NOI, ma se il vostro commerciante di base è esterno a NOI, si può essere in grado di trattare tutte le 62 come UnionPay.

    Si potrebbe anche essere richiesto per il trattamento di una scheda in modo diverso in base mercante di posizione. E. g. per il trattamento di alcune UNITO, carte di debito, a livello nazionale, ma come credito a livello internazionale.

    Ci sono molto utile set di regole mantenuti da una maggiore Acquisizione di Banca. E. g. https://www.barclaycard.co.uk/business/files/BIN-Rules-EIRE.pdf e https://www.barclaycard.co.uk/business/files/BIN-Rules-UK.pdf. (Link valido fino al giugno 2017, grazie all’utente che ha fornito un link di riferimento aggiornato.) Ma essere consapevoli del l’avvertenza che, mentre questi CRR regole può rappresentare il Rilascio della Carta universo in quanto si applica ai mercanti acquisita da tale entità, non sono, ad esempio, gli intervalli identificato come COPPA/UPI.

    Questi commenti si applicano a banda magnetica (banda magnetica) o PKE (Pan di Immissione della Chiave di scenari. La situazione è ancora diversa la ICC/EMV mondo.

    Aggiornamento: Altre risposte su questa pagina (e anche collegato pagina di WikiPedia) hanno JCB come sempre 16. Tuttavia, nella mia azienda abbiamo un team dedicato di ingegneri che certificare i nostri dispositivi POS e software su più banche acquirer e aree geografiche. La Certificazione più recente Pack di carte di questa squadra sono da JCB, aveva un pass caso per 19 lunghi PAN.

    • Avete un file aggiornato a Intervalli e le regole?
    • Ciao @CaiqueOliveira, vedi link aggiornati. Grazie per mac9416 che ha fornito un link aggiornato BIN-Norme di riferimento.
    • Grazie @mac9416, per l’aggiornamento BIN-Norme di riferimento.
  14. 3

    Swift Versione 2.1 di Usman Y answer.
    Utilizzare un’istruzione di stampa per verificare la così chiamata da parte di qualche valore stringa

    print(self.validateCardType(self.creditCardField.text!))
    
    func validateCardType(testCard: String) -> String {
    
        let regVisa = "^4[0-9]{12}(?:[0-9]{3})?$"
        let regMaster = "^5[1-5][0-9]{14}$"
        let regExpress = "^3[47][0-9]{13}$"
        let regDiners = "^3(?:0[0-5]|[68][0-9])[0-9]{11}$"
        let regDiscover = "^6(?:011|5[0-9]{2})[0-9]{12}$"
        let regJCB = "^(?:2131|1800|35\\d{3})\\d{11}$"
    
    
        let regVisaTest = NSPredicate(format: "SELF MATCHES %@", regVisa)
        let regMasterTest = NSPredicate(format: "SELF MATCHES %@", regMaster)
        let regExpressTest = NSPredicate(format: "SELF MATCHES %@", regExpress)
        let regDinersTest = NSPredicate(format: "SELF MATCHES %@", regDiners)
        let regDiscoverTest = NSPredicate(format: "SELF MATCHES %@", regDiscover)
        let regJCBTest = NSPredicate(format: "SELF MATCHES %@", regJCB)
    
    
        if regVisaTest.evaluateWithObject(testCard){
            return "Visa"
        }
        else if regMasterTest.evaluateWithObject(testCard){
            return "MasterCard"
        }
    
        else if regExpressTest.evaluateWithObject(testCard){
            return "American Express"
        }
    
        else if regDinersTest.evaluateWithObject(testCard){
            return "Diners Club"
        }
    
        else if regDiscoverTest.evaluateWithObject(testCard){
            return "Discover"
        }
    
        else if regJCBTest.evaluateWithObject(testCard){
            return "JCB"
        }
    
        return ""
    
    }
    
  15. 2

    La mia soluzione con jQuery:

    function detectCreditCardType() {
        var type = new Array;
        type[1] = '^4[0-9]{12}(?:[0-9]{3})?$';      //visa
        type[2] = '^5[1-5][0-9]{14}$';              //mastercard
        type[3] = '^6(?:011|5[0-9]{2})[0-9]{12}$';  //discover
        type[4] = '^3[47][0-9]{13}$';               //amex
    
        var ccnum = $('.creditcard').val().replace(/[^\d.]/g, '');
        var returntype = 0;
    
        $.each(type, function(idx, re) {
            var regex = new RegExp(re);
            if(regex.test(ccnum) && idx>0) {
                returntype = idx;
            }
        });
    
        return returntype;
    }
    

    Nel caso In cui il valore restituito è 0, tipo di carta di credito non viene rilevato.

    “carta di credito” classe dovrebbe essere aggiunto alla carta di credito del campo di input.

    • Variazione di answers.
    • Sì, ho usato il codice da le risposte di cui sopra, il MIGLIORAMENTO e postato qui. Grazie per il downvote…
    • Si dovrebbe avere (a) ha suggerito questo come un miglioramento del codice esistente, (b) scritto il contributi adeguati, o (c) di riferimento le fonti che hai utilizzato per scrivere le espressioni regolari.
    • Gajus, credo, ho aiutato la comunità, di modo che ho potuto, in quel momento, si prega di smettere di dirmi che dovevo aver fatto qualcosa per qualcuno. Ho fatto quello che ho pensato che potrebbe essere stata utile.
  16. 2

    Striscia ha fornito questo fantastico javascript biblioteca per schema di carta di rilevamento. Mi permetta di aggiungere alcuni frammenti di codice e di mostrare come usarlo.

    Includono in primo luogo a una pagina web come

    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery.payment/1.2.3/jquery.payment.js " ></script>
    

    In secondo luogo, utilizzare la funzione cardType per il rilevamento della carta di regime.

    $(document).ready(function() {              
                var type = $.payment.cardType("4242 4242 4242 4242"); //test card number
                console.log(type);                                   
    }); 
    

    Ecco il link di riferimento per ulteriori esempi e demo.

    1. Striscia blog per jquery.payment.js
    2. Repository Github
  17. 2

    Ho cercato in giro un po ‘ per la carta di credito la formattazione e il numero di telefono di formattazione. Trovato un sacco di buoni consigli, ma nulla di veramente adatto il mio esatto desideri, così ho creato questo pezzo di codice. Si usa come questo:

    var sf = smartForm.formatCC(myInputString);
    var cardType = sf.cardType;
    
  18. 2

    In swift è possibile creare un enum per rilevare il tipo di carta di credito.

    enum CreditCardType: Int { //Enum which encapsulates different card types and method to find the type of card.
    
    case Visa
    case Master
    case Amex
    case Discover
    
    func validationRegex() -> String {
        var regex = ""
        switch self {
        case .Visa:
            regex = "^4[0-9]{6,}$"
    
        case .Master:
            regex = "^5[1-5][0-9]{5,}$"
    
        case .Amex:
            regex = "^3[47][0-9]{13}$"
    
        case .Discover:
            regex = "^6(?:011|5[0-9]{2})[0-9]{12}$"
        }
    
        return regex
    }
    
    func validate(cardNumber: String) -> Bool {
        let predicate = NSPredicate(format: "SELF MATCHES %@", validationRegex())
        return predicate.evaluateWithObject(cardNumber)
    }
    
    //Method returns the credit card type for given card number
    static func cardTypeForCreditCardNumber(cardNumber: String) -> CreditCardType?  {
        var creditCardType: CreditCardType?
    
        var index = 0
        while let cardType = CreditCardType(rawValue: index) {
            if cardType.validate(cardNumber) {
                creditCardType = cardType
                break
            } else {
                index++
            }
        }
        return creditCardType
      }
    }
    

    Chiamare il metodo CreditCardType.cardTypeForCreditCardNumber(“#numero di carta”), che restituisce CreditCardType valore di enumerazione.

    • Opere meravigliose bro ti ringrazio tanto, tanto, tanto!!
  19. 1
    //abobjects.com, parvez ahmad ab bulk mailer
    use below script
    
    function isValidCreditCard2(type, ccnum) {
           if (type == "Visa") {
              //Visa: length 16, prefix 4, dashes optional.
              var re = /^4\d{3}?\d{4}?\d{4}?\d{4}$/;
           } else if (type == "MasterCard") {
              //Mastercard: length 16, prefix 51-55, dashes optional.
              var re = /^5[1-5]\d{2}?\d{4}?\d{4}?\d{4}$/;
           } else if (type == "Discover") {
              //Discover: length 16, prefix 6011, dashes optional.
              var re = /^6011?\d{4}?\d{4}?\d{4}$/;
           } else if (type == "AmEx") {
              //American Express: length 15, prefix 34 or 37.
              var re = /^3[4,7]\d{13}$/;
           } else if (type == "Diners") {
              //Diners: length 14, prefix 30, 36, or 38.
              var re = /^3[0,6,8]\d{12}$/;
           }
           if (!re.test(ccnum)) return false;
           return true;
           /*
           //Remove all dashes for the checksum checks to eliminate negative numbers
           ccnum = ccnum.split("-").join("");
           //Checksum ("Mod 10")
           //Add even digits in even length strings or odd digits in odd length strings.
           var checksum = 0;
           for (var i=(2-(ccnum.length % 2)); i<=ccnum.length; i+=2) {
              checksum += parseInt(ccnum.charAt(i-1));
           }
           //Analyze odd digits in even length strings or even digits in odd length strings.
           for (var i=(ccnum.length % 2) + 1; i<ccnum.length; i+=2) {
              var digit = parseInt(ccnum.charAt(i-1)) * 2;
              if (digit < 10) { checksum += digit; } else { checksum += (digit-9); }
           }
           if ((checksum % 10) == 0) return true; else return false;
           */
    
        }
    jQuery.validator.addMethod("isValidCreditCard", function(postalcode, element) { 
        return isValidCreditCard2($("#cardType").val(), $("#cardNum").val()); 
    
    }, "<br>credit card is invalid");
    
    
         Type</td>
                                              <td class="text">&nbsp; <form:select path="cardType" cssclass="fields" style="border: 1px solid #D5D5D5;padding: 0px 0px 0px 0px;width: 130px;height: 22px;">
                                                  <option value="SELECT">SELECT</option>
                                                  <option value="MasterCard">Mastercard</option>
                                                  <option value="Visa">Visa</option>
                                                   <option value="AmEx">American Express</option>
                                                  <option value="Discover">Discover</option>
                                                </form:select> <font color="#FF0000">*</font> 
    
    $("#signupForm").validate({
    
        rules:{
           companyName:{required: true},
           address1:{required: true},
           city:{required: true},
           state:{required: true},
           zip:{required: true},
           country:{required: true},
           chkAgree:{required: true},
           confPassword:{required: true},
           lastName:{required: true},
           firstName:{required: true},
           ccAddress1:{required: true},
           ccZip:{         
               postalcode : true
           },
           phone:{required: true},
           email:{
               required: true,
               email: true
               },
           userName:{
               required: true,
               minlength: 6
               },
           password:{
               required: true,
               minlength: 6
               },          
           cardNum:{           
                isValidCreditCard : true
           },
    
    • La domanda è la algoritmo per controllare una carta di credito, non una specifica implementazione. Che cosa fa questo codice?
  20. 1

    Solo un po ‘ di cucchiaio di alimentazione:

    $("#CreditCardNumber").focusout(function () {
    
    
            var regVisa = /^4[0-9]{12}(?:[0-9]{3})?$/;
            var regMasterCard = /^5[1-5][0-9]{14}$/;
            var regAmex = /^3[47][0-9]{13}$/;
            var regDiscover = /^6(?:011|5[0-9]{2})[0-9]{12}$/;
    
            if (regVisa.test($(this).val())) {
                $("#CCImage").html("<img height='40px' src='@Url.Content("~/images/visa.png")'>");          
    
            }
    
            else if (regMasterCard.test($(this).val())) {
            $("#CCImage").html("<img height='40px' src='@Url.Content("~/images/mastercard.png")'>");
    
            }
    
            else if (regAmex.test($(this).val())) {
    
               $("#CCImage").html("<img height='40px' src='@Url.Content("~/images/amex.png")'>");
    
            }
             else if (regDiscover.test($(this).val())) {
    
               $("#CCImage").html("<img height='40px' src='@Url.Content("~/images/discover.png")'>");
    
            }
            else {
            $("#CCImage").html("NA");
    
            }
    
        });
    
  21. 1

    Ecco un esempio di alcune funzioni booleane scritto in Python che restituiscono True se la scheda viene rilevata come per il nome della funzione.

    def is_american_express(cc_number):
        """Checks if the card is an american express. If us billing address country code, & is_amex, use vpos
        https://en.wikipedia.org/wiki/Bank_card_number#cite_note-GenCardFeatures-3
        :param cc_number: unicode card number
        """
        return bool(re.match(r'^3[47][0-9]{13}$', cc_number))
    
    
    def is_visa(cc_number):
        """Checks if the card is a visa, begins with 4 and 12 or 15 additional digits.
        :param cc_number: unicode card number
        """
    
        # Standard Visa is 13 or 16, debit can be 19
        if bool(re.match(r'^4', cc_number)) and len(cc_number) in [13, 16, 19]:
            return True
    
        return False
    
    
    def is_mastercard(cc_number):
        """Checks if the card is a mastercard. Begins with 51-55 or 2221-2720 and 16 in length.
        :param cc_number: unicode card number
        """
        if len(cc_number) == 16 and cc_number.isdigit():  # Check digit, before cast to int
            return bool(re.match(r'^5[1-5]', cc_number)) or int(cc_number[:4]) in range(2221, 2721)
        return False
    
    
    def is_discover(cc_number):
        """Checks if the card is discover, re would be too hard to maintain. Not a supported card.
        :param cc_number: unicode card number
        """
        if len(cc_number) == 16:
            try:
                # return bool(cc_number[:4] == '6011' or cc_number[:2] == '65' or cc_number[:6] in range(622126, 622926))
                return bool(cc_number[:4] == '6011' or cc_number[:2] == '65' or 622126 <= int(cc_number[:6]) <= 622925)
            except ValueError:
                return False
        return False
    
    
    def is_jcb(cc_number):
        """Checks if the card is a jcb. Not a supported card.
        :param cc_number: unicode card number
        """
        # return bool(re.match(r'^(?:2131|1800|35\d{3})\d{11}$', cc_number))  # wikipedia
        return bool(re.match(r'^35(2[89]|[3-8][0-9])[0-9]{12}$', cc_number))  # PawelDecowski
    
    
    def is_diners_club(cc_number):
        """Checks if the card is a diners club. Not a supported card.
        :param cc_number: unicode card number
        """
        return bool(re.match(r'^3(?:0[0-6]|[68][0-9])[0-9]{11}$', cc_number))  # 0-5 = carte blance, 6 = international
    
    
    def is_laser(cc_number):
        """Checks if the card is laser. Not a supported card.
        :param cc_number: unicode card number
        """
        return bool(re.match(r'^(6304|670[69]|6771)', cc_number))
    
    
    def is_maestro(cc_number):
        """Checks if the card is maestro. Not a supported card.
        :param cc_number: unicode card number
        """
        possible_lengths = [12, 13, 14, 15, 16, 17, 18, 19]
        return bool(re.match(r'^(50|5[6-9]|6[0-9])', cc_number)) and len(cc_number) in possible_lengths
    
    
    # Child cards
    
    def is_visa_electron(cc_number):
        """Child of visa. Checks if the card is a visa electron. Not a supported card.
        :param cc_number: unicode card number
        """
        return bool(re.match(r'^(4026|417500|4508|4844|491(3|7))', cc_number)) and len(cc_number) == 16
    
    
    def is_total_rewards_visa(cc_number):
        """Child of visa. Checks if the card is a Total Rewards Visa. Not a supported card.
        :param cc_number: unicode card number
        """
        return bool(re.match(r'^41277777[0-9]{8}$', cc_number))
    
    
    def is_diners_club_carte_blanche(cc_number):
        """Child card of diners. Checks if the card is a diners club carte blance. Not a supported card.
        :param cc_number: unicode card number
        """
        return bool(re.match(r'^30[0-5][0-9]{11}$', cc_number))  # github PawelDecowski, jquery-creditcardvalidator
    
    
    def is_diners_club_carte_international(cc_number):
        """Child card of diners. Checks if the card is a diners club international. Not a supported card.
        :param cc_number: unicode card number
        """
        return bool(re.match(r'^36[0-9]{12}$', cc_number))  # jquery-creditcardvalidator
    
  22. 0

    L’espressione regolare regole che corrispondono alla rispettivi fornitori di schede:

    • (4\d{12}(?:\d{3})?) per il VISTO.
    • (5[1-5]\d{14}) per MasterCard.
    • (3[47]\d{13}) AMEX.
    • ((?:5020|5038|6304|6579|6761)\d{12}(?:\d\d)?) per Maestro.
    • (3(?:0[0-5]|[68][0-9])[0-9]{11}) per Diners Club.
    • (6(?:011|5[0-9]{2})[0-9]{12}) per Scoprire.
    • (35[2-8][89]\d\d\d{10}) per JCB.
    • Penso che regex per JCB non è corretto. Tutte le prime quattro cifre tra 3528 e 3589 dovrebbe essere accettato, ma 3570 non è, per esempio.
  23. 0

    Le prime sei cifre del numero della carta (compresa quella iniziale MII
    cifre) sono noti come numero di identificazione emittente (IIN). Questi
    identificare l’emittente della carta di istituto che ha emesso la carta per la carta
    titolare. Il resto del numero è assegnato da parte dell’emittente della carta. Il
    il numero di carta di lunghezza è il numero di cifre. Molte emittenti di carte di stampa
    l’intero IIN e il numero di conto sulla loro carta.

    Basato su fatti di cui sopra vorrei mantenere un frammento di JAVA codice per la carta d’identità del brand.

    Campione tipi di schede di

    public static final String AMERICAN_EXPRESS = "American Express";
    public static final String DISCOVER = "Discover";
    public static final String JCB = "JCB";
    public static final String DINERS_CLUB = "Diners Club";
    public static final String VISA = "Visa";
    public static final String MASTERCARD = "MasterCard";
    public static final String UNKNOWN = "Unknown";
    

    Carta Prefissi

    //Based on http://en.wikipedia.org/wiki/Bank_card_number#Issuer_identification_number_.28IIN.29
    public static final String[] PREFIXES_AMERICAN_EXPRESS = {"34", "37"};
    public static final String[] PREFIXES_DISCOVER = {"60", "62", "64", "65"};
    public static final String[] PREFIXES_JCB = {"35"};
    public static final String[] PREFIXES_DINERS_CLUB = {"300", "301", "302", "303", "304", "305", "309", "36", "38", "39"};
    public static final String[] PREFIXES_VISA = {"4"};
    public static final String[] PREFIXES_MASTERCARD = {
            "2221", "2222", "2223", "2224", "2225", "2226", "2227", "2228", "2229",
            "223", "224", "225", "226", "227", "228", "229",
            "23", "24", "25", "26",
            "270", "271", "2720",
            "50", "51", "52", "53", "54", "55"
        };
    

    Controllare per vedere se il numero inserito è qualsiasi dato prefissi.

    public String getBrand(String number) {
    
    String evaluatedType;
    if (StripeTextUtils.hasAnyPrefix(number, PREFIXES_AMERICAN_EXPRESS)) {
        evaluatedType = AMERICAN_EXPRESS;
    } else if (StripeTextUtils.hasAnyPrefix(number, PREFIXES_DISCOVER)) {
        evaluatedType = DISCOVER;
    } else if (StripeTextUtils.hasAnyPrefix(number, PREFIXES_JCB)) {
        evaluatedType = JCB;
    } else if (StripeTextUtils.hasAnyPrefix(number, PREFIXES_DINERS_CLUB)) {
        evaluatedType = DINERS_CLUB;
    } else if (StripeTextUtils.hasAnyPrefix(number, PREFIXES_VISA)) {
        evaluatedType = VISA;
    } else if (StripeTextUtils.hasAnyPrefix(number, PREFIXES_MASTERCARD)) {
        evaluatedType = MASTERCARD;
    } else {
        evaluatedType = UNKNOWN;
    }
        return evaluatedType;
    }
    

    Infine, Il metodo di Utilità

    /**
      * Check to see if the input number has any of the given prefixes.
      *
      * @param number the number to test
      * @param prefixes the prefixes to test against
      * @return {@code true} if number begins with any of the input prefixes
    */
    
    public static boolean hasAnyPrefix(String number, String... prefixes) {
      if (number == null) {
           return false;
      }
       for (String prefix : prefixes) {
           if (number.startsWith(prefix)) {
           return true;
        }
      }
         return false;
    }
    

    Di riferimento

  24. 0

    Io uso https://github.com/bendrucker/creditcards-types/ per rilevare il tipo di carta di credito numero. Unico problema che ho incontrato è scoprire il numero di test
    6011 1111 1111 1117

    da https://www.cybersource.com/developers/other_resources/quick_references/test_cc_numbers/
    possiamo vedere si tratta di una scoperta di numero, perché comincia da 6011. Ma il risultato mi da la carta di credito è “Maestro”. Ho aperto il problema per l’autore. Ha risposto a me molto presto e di fornire questo pdf doc https://www.discovernetwork.com/downloads/IPP_VAR_Compliance.pdf
    Il doc si può vedere chiaramente che 6011 1111 1111 1117 non rientrano nella gamma di scoprire la carta di credito.

    • Sto avendo lo stesso problema , hai preso questa fissa?
    • Penso che il discovernetwork.com file pdf è più affidabile. E il numero 6011 1111 1111 1117 è solo una prova di un numero reale carta di credito ha questo numero. Quindi penso che non c’è bisogno di preoccuparsi di questo.
    • Sembra che ci sia qualche bug con alcuni Discover card, ho provato valido numero e ho sempre quel messaggio di errore.
    • si può fornire il numero e presentare un problema su github?
  25. 0

    Provare questo.Per swift.

    func checkCardValidation(number : String) -> Bool
    {
        let reversedInts = number.characters.reversed().map { Int(String($0)) }
            return reversedInts.enumerated().reduce(0, {(sum, val) in
                let odd = val.offset % 2 == 1
                return sum + (odd ? (val.element! == 9 ? 9 : (val.element! * 2) % 9) : val.element!)
            }) % 10 == 0
    }
    

    Uso.

    if (self.checkCardValidation(number: "yourNumber") == true) {
         print("Card Number valid")
    }else{
         print("Card Number not valid")
    }
    
  26. 0
    follow Luhn’s algorithm
    
     private  boolean validateCreditCardNumber(String str) {
    
            int[] ints = new int[str.length()];
            for (int i = 0; i < str.length(); i++) {
                ints[i] = Integer.parseInt(str.substring(i, i + 1));
            }
            for (int i = ints.length - 2; i >= 0; i = i - 2) {
                int j = ints[i];
                j = j * 2;
                if (j > 9) {
                    j = j % 10 + 1;
                }
                ints[i] = j;
            }
            int sum = 0;
            for (int i = 0; i < ints.length; i++) {
                sum += ints[i];
            }
            if (sum % 10 == 0) {
               return true;
            } else {
                return false;
            }
    
    
        }
    
    then call this method
    
    Edittext mCreditCardNumberEt;
    
     mCreditCardNumberEt.addTextChangedListener(new TextWatcher() {
                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
    
                }
    
                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {
    
                 int cardcount=   s.toString().length();
                     if(cardcount>=16) {
                        boolean cardnumbervalid=   validateCreditCardNumber(s.toString());
                        if(cardnumbervalid) {
                            cardvalidtesting.setText("Valid Card");
                            cardvalidtesting.setTextColor(ContextCompat.getColor(context,R.color.green));
                        }
                        else {
                            cardvalidtesting.setText("Invalid Card");
                            cardvalidtesting.setTextColor(ContextCompat.getColor(context,R.color.red));
                        }
                    }
                   else if(cardcount>0 &&cardcount<16) {
                         cardvalidtesting.setText("Invalid Card");
                         cardvalidtesting.setTextColor(ContextCompat.getColor(context,R.color.red));
                    }
    
                    else {
                        cardvalidtesting.setText("");
    
                    }
    
    
                    }
    
                @Override
                public void afterTextChanged(Editable s) {
    
                }
            });
    

Lascia un commento