algorithm - आप संख्या के आधार पर क्रेडिट कार्ड प्रकार का पता कैसे लगाते हैं?




language-agnostic e-commerce (18)

The first six digits of a card number (including the initial MII digit) are known as the issuer identification number (IIN). These identify the card issuing institution that issued the card to the card holder. The rest of the number is allocated by the card issuer. The card number's length is its number of digits. Many card issuers print the entire IIN and account number on their card.

Based on the above facts I would like to keep a snippet of JAVA code to identify card brand.

Sample card types

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

Card Prefixes

// 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"
    };

Check to see if the input number has any of the given prefixes.

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

Finally, The Utility method

/**
  * 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;
}

Reference

मैं यह पता लगाने की कोशिश कर रहा हूं कि क्रेडिट नंबर के प्रकार को पूरी तरह से अपने नंबर पर कैसे पहचानें। क्या किसी को यह खोजने के लिए एक निश्चित, विश्वसनीय तरीका पता है?


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

0 लौटाए जाने पर, क्रेडिट कार्ड का प्रकार ज्ञात नहीं है।

"क्रेडिट कार्ड" वर्ग क्रेडिट कार्ड इनपुट फ़ील्ड में जोड़ा जाना चाहिए।


इसकी जांच करें:

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

कार्ड रेंज रिकग्निशन (सीआरआर) में, एल्गोरिदम के साथ एक दोष जो रेगेक्स या अन्य हार्ड-कोडित श्रेणियों की श्रृंखला का उपयोग करता है, यह है कि बीआईएन / आईआईएन मेरे अनुभव में समय के साथ बदलते हैं। कार्ड का सह-ब्रांडिंग एक सतत जटिलता है। भौगोलिक स्थान के आधार पर अलग-अलग कार्ड प्राप्तकर्ता / व्यापारियों को आपको एक ही कार्ड का अलग-अलग इलाज करने की आवश्यकता हो सकती है।

इसके अतिरिक्त, पिछले कुछ वर्षों में व्यापक परिसंचरण में यूनियनपे कार्ड के साथ, मौजूदा मॉडल नई श्रेणियों का सामना नहीं करते हैं जो कभी-कभी व्यापक श्रेणी के साथ हस्तक्षेप करते हैं।
भूगोल को जानने के लिए आपके सिस्टम को कवर करने की ज़रूरत है, क्योंकि कुछ श्रेणियां विशेष देशों में उपयोग करने के लिए प्रतिबंधित हैं। उदाहरण के लिए, 62 में अमेरिका में कुछ एएए उप-श्रेणियां शामिल हैं, लेकिन यदि आपका व्यापारी आधार यूएस के बाहर है, तो आप सभी 62 को यूनियनपे के रूप में इलाज करने में सक्षम हो सकते हैं।
आपको व्यापारी स्थान के आधार पर अलग-अलग कार्ड का इलाज करने के लिए भी कहा जा सकता है। कुछ यूके कार्डों को घरेलू रूप से डेबिट के रूप में पेश करने के लिए, लेकिन अंतरराष्ट्रीय स्तर पर क्रेडिट के रूप में।

एक प्रमुख अधिग्रहण बैंक द्वारा बनाए गए नियमों का बहुत उपयोगी सेट है। जैसे https://www.barclaycard.co.uk/business/files/BIN-Rules-EIRE.pdf नियम- https://www.barclaycard.co.uk/business/files/BIN-Rules-EIRE.pdf और https://www.barclaycard.co.uk/business/files/BIN-Rules-UK.pdf । (जून 2017 के रूप में मान्य लिंक, जो उपयोगकर्ता ने अद्यतन संदर्भ के लिए एक लिंक प्रदान किया है, धन्यवाद।) लेकिन चेतावनी से अवगत रहें कि, जबकि इन सीआरआर नियम कार्ड जारी करने वाले ब्रह्मांड का प्रतिनिधित्व कर सकते हैं क्योंकि यह उस इकाई द्वारा अधिग्रहित व्यापारियों पर लागू होता है, इसमें सीयूपी / यूपीआई के रूप में पहचाने गए श्रेणियां शामिल नहीं हैं।

ये टिप्पणियां चुंबकीय पट्टी (मैगस्ट्रिप) या पीकेई (पैन कुंजी प्रविष्टि) परिदृश्य पर लागू होती हैं। आईसीसी / ईएमवी दुनिया में स्थिति फिर से अलग है।

अपडेट करें: इस पृष्ठ पर अन्य उत्तरों (और लिंक किए गए विकीपीडिया पेज) में जेसीबी हमेशा 16 लम्बा है। हालांकि, मेरी कंपनी में हमारे पास इंजीनियरों की एक समर्पित टीम है जो हमारे पीओएस उपकरणों और सॉफ्टवेयर को कई अधिग्रहण बैंकों और भौगोलिक क्षेत्रों में प्रमाणित करती है। जेसीबी से इस टीम के कार्ड का हालिया प्रमाणन पैक, 1 9 लंबे पैन के लिए पास केस था।



क्रेडिट / डेबिट कार्ड नंबर को पैन , या प्राथमिक खाता संख्या के रूप में जाना जाता है। पैन के पहले छह अंक आईआईएन , या जारीकर्ता बैंक से संबंधित जारीकर्ता पहचान संख्या से लिया जाता है (आईआईएन को पहले बीआईएन - बैंक पहचान संख्या के रूप में जाना जाता था - ताकि आप कुछ दस्तावेजों में उस शब्दावली के संदर्भ देख सकें)। ये छः अंक एक अंतरराष्ट्रीय मानक, आईएसओ / आईईसी 7812 के अधीन हैं, और संख्या से कार्ड के प्रकार को निर्धारित करने के लिए इस्तेमाल किया जा सकता है।

दुर्भाग्यवश वास्तविक आईएसओ / आईईसी 7812 डेटाबेस सार्वजनिक रूप से उपलब्ध नहीं है, हालांकि विकिपीडिया सहित वाणिज्यिक और मुक्त दोनों अनौपचारिक सूचियां हैं।

वैसे भी, संख्या से प्रकार का पता लगाने के लिए, आप नीचे की तरह एक नियमित अभिव्यक्ति का उपयोग कर सकते हैं: मूल अभिव्यक्तियों के लिए क्रेडिट

वीज़ा: ^4[0-9]{6,}$ वीज़ा कार्ड नंबर 4 के साथ शुरू होते हैं।

मास्टरकार्ड: ^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,}$ 2016 से पहले, मास्टरकार्ड संख्याएं शुरू होती हैं 51 से 55 के नंबर, लेकिन यह केवल मास्टरकार्ड क्रेडिट कार्ड का पता लगाएगा ; मास्टरकार्ड सिस्टम का उपयोग करके जारी किए गए अन्य कार्ड हैं जो इस आईआईएन रेंज में नहीं आते हैं। 2016 में, वे सीमा में संख्याएं जोड़ देंगे (222100-2720 99)।

अमेरिकन एक्सप्रेस: ^3[47][0-9]{5,}$ अमेरिकन एक्सप्रेस कार्ड नंबर 34 या 37 के साथ शुरू होते हैं।

डायनर्स क्लब: ^3(?:0[0-5]|[68][0-9])[0-9]{4,}$ डिनर क्लब कार्ड नंबर 300 से 305, 36 या 38 के साथ शुरू होते हैं। डिनर क्लब कार्ड जो 5 से शुरू होते हैं और 16 अंक होते हैं। ये डिनर क्लब और मास्टरकार्ड के बीच संयुक्त उद्यम हैं, और मास्टरकार्ड की तरह संसाधित किया जाना चाहिए।

डिस्कवर: ^6(?:011|5[0-9]{2})[0-9]{3,}$ डिस्कवर कार्ड नंबर 6011 या 65 के साथ शुरू होते हैं।

जेसीबी: ^(?:2131|1800|35[0-9]{3})[0-9]{3,}$ जेसीबी कार्ड 2131, 1800 या 35 के साथ शुरू होते हैं।

दुर्भाग्यवश मास्टरकार्ड सिस्टम के साथ संसाधित कई प्रकार के कार्ड हैं जो मास्टरकार्ड की आईआईएन रेंज में नहीं रहते हैं (51 से शुरू होने वाली संख्याएं ... 55); सबसे महत्वपूर्ण मामला मेस्ट्रो कार्डों का है, जिनमें से कई अन्य बैंकों की आईआईएन श्रेणियों से जारी किए गए हैं और इसलिए सभी जगहों पर स्थित हैं। नतीजतन, यह मानना ​​सबसे अच्छा हो सकता है कि कोई भी कार्ड जो आपके द्वारा स्वीकार किए जाने वाले किसी अन्य प्रकार का नहीं है, वह मास्टरकार्ड होना चाहिए

महत्वपूर्ण : कार्ड संख्या लंबाई में भिन्न होती है; उदाहरण के लिए, वीजा ने 13 अंकों के पैन और 16 अंकों के पैन वाले कार्ड वाले कार्ड जारी किए हैं। वीज़ा का दस्तावेज वर्तमान में इंगित करता है कि यह 12 और 1 9 अंकों के बीच जारी संख्या जारी कर सकता है या हो सकता है। इसलिए, आपको यह सत्यापित करने के अलावा कार्ड नंबर की लंबाई की जांच नहीं करनी चाहिए कि इसमें कम से कम 7 अंक हैं (एक पूर्ण आईआईएन प्लस एक चेक अंक के लिए, जो लुहान एल्गोरिदम द्वारा अनुमानित मूल्य से मेल खाना चाहिए)।

एक और संकेत: कार्डधारक पैन को संसाधित करने से पहले, इनपुट से किसी भी सफेद जगह और विराम चिह्नों को पट्टी करें । क्यूं कर? चूंकि समूह में अंकों को दर्ज करना आम तौर पर अधिक आसान होता है, इसी तरह वे वास्तविक क्रेडिट कार्ड के सामने प्रदर्शित होते हैं, यानी

4444 4444 4444 4444

से सही ढंग से दर्ज करना बहुत आसान है

4444444444444444

उपयोगकर्ता को दंडित करने में वास्तव में कोई फायदा नहीं है क्योंकि उन्होंने उन पात्रों में प्रवेश किया है जिनकी आप अपेक्षा नहीं करते हैं।

यह भी सुनिश्चित करता है कि आपके प्रवेश फ़ील्ड में कम से कम 24 वर्णों के लिए कमरा है, अन्यथा जो स्थान रिक्त स्थान दर्ज करते हैं वे कमरे से बाहर हो जाएंगे। मैं अनुशंसा करता हूं कि आप 32 अक्षरों को प्रदर्शित करने के लिए पर्याप्त चौड़ा क्षेत्र बनाएं और 64 तक की अनुमति दें; जो विस्तार के लिए बहुत सारे हेडरूम देता है।

यहां एक ऐसी छवि है जो थोड़ा और अंतर्दृष्टि प्रदान करती है:

अद्यतन (2014): चेकसम विधि अब इस उत्तर की टिप्पणियों में उल्लिखित कार्ड की प्रामाणिकता की पुष्टि करने का एक वैध तरीका प्रतीत नहीं होता है

अद्यतन (2016): मास्टरकार्ड अच भुगतान शुरू करने वाली नई बिन श्रेणियों को लागू करना है।


भुगतान संसाधित करने के हिस्से के रूप में क्रेडिट कार्ड प्रकार का पता लगाने की कोशिश न करें। आप वैध लेनदेन को कम करने का जोखिम उठा रहे हैं।

अगर आपको अपने भुगतान प्रोसेसर को जानकारी प्रदान करने की आवश्यकता है (उदाहरण के लिए पेपैल क्रेडिट कार्ड ऑब्जेक्ट को कार्ड प्रकार का नाम देना आवश्यक है), तो इसे उपलब्ध कम से कम जानकारी से अनुमान लगाएं, उदाहरण के लिए

$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.');
}

यह कार्यान्वयन (केवल पहले दो अंकों का उपयोग करके) सभी प्रमुख (और पेपैल के मामले में सभी समर्थित) कार्ड योजनाओं की पहचान करने के लिए पर्याप्त है। असल में, आप अपवाद को पूरी तरह से और डिफ़ॉल्ट रूप से सबसे लोकप्रिय कार्ड प्रकार में छोड़ना चाहते हैं। भुगतान गेटवे / प्रोसेसर को बताएं कि आपके अनुरोध के जवाब में सत्यापन त्रुटि है या नहीं।

हकीकत यह है कि आपका भुगतान गेटवे आपके द्वारा प्रदान किए जाने वाले मूल्य की परवाह नहीं करता है


यहां एक php क्लास फ़ंक्शन CCCumber द्वारा CCtype देता है।
यह कोड कार्ड को मान्य नहीं करता है या नहीं चलता है लुहान एल्गोरिदम केवल इस पृष्ठ में तालिका के आधार पर क्रेडिट कार्ड प्रकार खोजने का प्रयास करता है। सीसीकार्ड प्रकार निर्धारित करने के लिए मूल रूप से सीसीएनंबर लंबाई और सीसीकार्ड उपसर्ग का उपयोग करता है।

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

हाल ही में मुझे ऐसी कार्यक्षमता की आवश्यकता है, मैं रूबे के लिए ज़ेंड फ्रेमवर्क क्रेडिट कार्ड वैलिडेटर पोर्ट कर रहा था। रूबी मणि: https://github.com/Fivell/credit_card_validations ज़ेंड फ्रेमवर्क: https://github.com/zendframework/zf2/blob/master/library/Zend/Validator/CreditCard.php

वे दोनों प्रकार का पता लगाने के लिए आईएनएन श्रेणियों का उपयोग करते हैं। यहां आप आईएनएन के बारे में पढ़ सकते हैं

इसके अनुसार आप वैकल्पिक रूप से क्रेडिट कार्ड का पता लगा सकते हैं (regexps के बिना, लेकिन उपसर्गों और संभावित लंबाई के बारे में कुछ नियम घोषित कर सकते हैं)

तो हमारे पास सबसे अधिक इस्तेमाल किए जाने वाले कार्ड के लिए अगले नियम हैं

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

}

फिर उपसर्ग खोजकर और लंबाई की तुलना करके आप क्रेडिट कार्ड ब्रांड का पता लगा सकते हैं। लुहान एल्गोरिदम के बारे में भी मत भूलना (यह यहां http://en.wikipedia.org/wiki/Luhn का हकदार है)।


अपडेटेडः 15 जून 2016 (वर्तमान में एक अंतिम समाधान के रूप में)

कृपया ध्यान दें कि मैं भी वोट देने के लिए वोट देता हूं, लेकिन इसे स्पष्ट करने के लिए ये रेगेक्स वास्तव में काम करता है, मैंने इसे हजारों वास्तविक बीआईएन कोडों के साथ परीक्षण किया। प्रारंभिक स्ट्रिंग्स (^) का उपयोग करना सबसे महत्वपूर्ण है अन्यथा यह वास्तविक दुनिया में झूठे परिणाम देगा!

जेसीबी ^(?:2131|1800|35)[0-9]{0,}$ साथ शुरू करें: 2131, 1800, 35 (3528-3589)

अमेरिकन एक्सप्रेस ^3[47][0-9]{0,}$ साथ शुरू करें: 34, 37

डायनर्स क्लब ^3(?:0[0-59]{1}|[689])[0-9]{0,}$ साथ शुरू करें: 300-305, 30 9, 36, 38-39

वीज़ा ^4[0-9]{0,}$ साथ शुरू करें: 4

मास्टरकार्ड ^(5[1-5]|222[1-9]|22[3-9]|2[3-6]|27[01]|2720)[0-9]{0,}$ साथ शुरू करें : 2221-2720, 51-55

मेस्ट्रो ^(5[06789]|6)[0-9]{0,}$ मेस्ट्रो हमेशा सीमा में बढ़ रहा है: 60-69 , कुछ और के साथ शुरू हुआ, लेकिन शुरूआत 5 को मास्टरकार्ड के रूप में एन्कोड किया जाना चाहिए। कोड के अंत में मेस्ट्रो कार्ड का पता लगाया जाना चाहिए क्योंकि कुछ अन्य 60-69 की सीमा में हैं। कृपया कोड देखें।

डिस्कवर ^(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

जावास्क्रिप्ट में मैं इस फ़ंक्शन का उपयोग करता हूं। यह अच्छा होता है जब आप इसे ऑनकीप ईवेंट में असाइन करते हैं और यह जितनी जल्दी हो सके परिणाम देता है।

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

यहां आप इसके साथ खेल सकते हैं:

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

PHP के लिए इस फ़ंक्शन का उपयोग करें, यह कुछ उप वीज़ा / एमसी कार्ड भी पहचानता है:

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

I searched around quite a bit for credit card formatting and phone number formatting. Found lots of good tips but nothing really suited my exact desires so I created quercusv.github.io/smartForm . आप इसे इस तरह इस्तेमाल करते हैं:

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

I use https://github.com/bendrucker/creditcards-types/ to detect the credit card type from number. One issue I ran into is discover test number 6011 1111 1111 1117

from https://www.cybersource.com/developers/other_resources/quick_references/test_cc_numbers/ we can see it is a discover number because it starts by 6011. But the result I get from the creditcards-types is "Maestro". I opened the issue to the author. He replied me very soon and provide this pdf doc https://www.discovernetwork.com/downloads/IPP_VAR_Compliance.pdf From the doc we can see clearly that 6011 1111 1111 1117 does not fall into the range of discover credit card.


Just a little spoon feeding:

$("#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");

        }

    });

Stripe has provided this fantastic javascript library for card scheme detection. Let me add few code snippets and show you how to use it.

Firstly Include it to your web page as

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

Secondly use the function cardType for detecting the card scheme.

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

Here are the reference links for more examples and demos.

  1. Stripe blog for jquery.payment.js
  2. Github repository

The regular expression rules that match the respective card vendors :

  • (4\d{12}(?:\d{3})?) for VISA.
  • (5[1-5]\d{14}) for MasterCard.
  • (3[47]\d{13}) for AMEX.
  • ((?:5020|5038|6304|6579|6761)\d{12}(?:\d\d)?) for Maestro.
  • (3(?:0[0-5]|[68][0-9])[0-9]{11}) for Diners Club.
  • (6(?:011|5[0-9]{2})[0-9]{12}) for Discover.
  • (35[2-8][89]\d\d\d{10}) for JCB.

Try this.For 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
}

Use.

if (self.checkCardValidation(number: "yourNumber") == true) {
     print("Card Number valid")
}else{
     print("Card Number not valid")
}

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

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

            }
        });




e-commerce