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

516

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

algorithm  language-agnostic  e-commerce 
— एंड्रयू एडवांसन
स्रोत
3
एक नियमित अभिव्यक्ति का उपयोग करना। की जाँच करें इस लिंक अधिक जानकारी के लिए।
— सेनफो
3
विवरण सभी विकिपीडिया पर हैं: en.wikipedia.org/wiki/Credit_card_numbers
— स्टेन वेस्टरली
1
En.wikipedia.org/wiki/Credit_card_numbers पर विकिपीडिया में एक अच्छी सारांश तालिका है । यह पहला एक से छह अंक है जो कार्ड के प्रकार और जारीकर्ता को बताता है।
— एलेक्स
3
मैं पहले संख्यात्मक समूह को बाहर निकालने के अलावा अन्य रेगेक्स का उपयोग नहीं करूंगा, आप आम तौर पर पहले 4 नंबर (यूएस में) से बता सकते हैं। चार्ज क्लियर करने के भुगतान के लिए परेशान होने से पहले यह सुनिश्चित करने के लिए कार्ड नंबर पर एक मॉड 10 चेकसम रन करें कि यह वैध हो सकता है। लुहन एल्गोरिथ्म
— दान ब्लेयर
3
अगर कोई इन एल्गोरिदम को 'सभी समय के लिए अच्छा' कह सकता है, तो भी कोई टिप्पणी कर सकता है - या क्या वे समय-समय पर बदलते हैं, उदाहरण के लिए एल्गोरिथ्म के लिए 'गणना करने के लिए कि क्या एक फोन नंबर कैलिफ़ोर्निया में है'
— सिमोन_विवर

जवाबों:

771

क्रेडिट / डेबिट कार्ड नंबर को पैन या प्राथमिक खाता संख्या के रूप में जाना जाता है । पैन के पहले छह अंक IIN , या जारीकर्ता पहचान संख्या से लिए गए हैं, जो जारीकर्ता बैंक से संबंधित हैं (IIN को पहले BIN - बैंक पहचान संख्या के रूप में जाना जाता था - इसलिए आप कुछ दस्तावेजों में उस शब्दावली के संदर्भ देख सकते हैं)। ये छह अंक एक अंतरराष्ट्रीय मानक, आईएसओ / आईईसी 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 से पहले, मास्टरकार्ड 55 के माध्यम से 51 नंबर से शुरू होता है, लेकिन यह केवल मास्टर कार्ड क्रेडिट कार्ड का पता लगाएगा ; मास्टर कार्ड प्रणाली का उपयोग करते हुए अन्य कार्ड जारी किए गए हैं जो इस आईआईएन श्रेणी में नहीं आते हैं। 2016 में, वे रेंज (222100-272099) में नंबर जोड़ देंगे।

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

डाइनर्स क्लब: ^3(?:0[0-5]|[68][0-9])[0-9]{4,}$ डिनर क्लब कार्ड संख्या 305, 36 या 38 के माध्यम से 300 से शुरू होती है। डिनर क्लब कार्ड ऐसे होते हैं जो 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 और 19 अंकों के बीच अंक जारी कर सकता है या हो सकता है। इसलिए, आपको कार्ड नंबर की लंबाई की जांच नहीं करनी चाहिए, यह सत्यापित करने के अलावा कि इसमें कम से कम 7 अंक हैं (पूर्ण आईआईएन प्लस एक चेक अंक के लिए, जो कि लुहान एल्गोरिदम द्वारा अनुमानित मूल्य से मेल खाना चाहिए )।

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

4444 4444 4444 4444

की तुलना में सही ढंग से प्रवेश करने के लिए बहुत आसान है

4444444444444444

उपयोगकर्ता का पीछा करने में वास्तव में कोई लाभ नहीं है क्योंकि वे उन पात्रों में प्रवेश कर चुके हैं जिनकी आप यहाँ अपेक्षा नहीं करते हैं।

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

यहाँ एक छवि है जो थोड़ी और जानकारी देती है:

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

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

क्रेडिट कार्ड सत्यापन

— senfo
स्रोत
7
महान उदाहरण है। क्या आपके पास मेस्ट्रो कार्ड के लिए नियमित अभिव्यक्ति है?
— मणिकंदन
4
नहीं नहीं नहीं। आप कार्ड संख्या की लंबाई पर भरोसा नहीं कर सकते हैं; वे किसी भी समय बदल सकते हैं। कार्ड नंबर का एकमात्र हिस्सा जिस पर आप भरोसा कर सकते हैं वह है IIN (जिसे BIN कहा जाता था) और जो संख्या का एक उपसर्ग है। इसके अतिरिक्त, आप मास्टरकार्ड कार्डों का पता लगाने के तरीके से पता नहीं लगा सकते हैं; यह केवल मास्टर कार्ड सिस्टम के माध्यम से संसाधित किए जाने वाले कार्डों का एक सबसेट (मुख्य समस्या यह है कि Maestro कार्ड, जिसमें IIN उपसर्गों की एक किस्म है) उठाएगा।
— एलेस्टेयर
2
@alastair क्या आपने टिप्पणी करने से पहले भाव पढ़े थे? वे विशेष रूप से IIN का उपयोग करने के लिए लिखे गए थे, इसलिए मुझे समझ नहीं आ रहा है कि आप क्या कहना चाह रहे हैं। इसके अलावा, IIN का उपयोग कार्ड जारीकर्ता की पहचान करने के लिए किया जा सकता है, लेकिन मान्य नहीं। 5412, उदाहरण के लिए, एक पूर्ण मास्टरकार्ड का प्रतिनिधित्व नहीं करता है, लेकिन आपका सुझाव इसका मतलब होगा कि यह करता है। मुझे कोई सबूत नहीं मिला कि मास्टरकार्ड 16 अंकों का कुछ भी हो। कृपया अपने दावे के लिए एक स्रोत प्रदान करने के लिए स्वतंत्र महसूस करें। आप Maestro कार्ड के लिए किए जाने वाले अपडेट की आवश्यकता का उल्लेख करने में सही हैं, हालाँकि।
— सेनफियो
3
@senfo आप सही कह रहे हैं, 5412 एक पूर्ण मास्टरकार्ड संख्या नहीं होगी। IIN छह अंक लंबे होते हैं, इसलिए एक पूर्ण कार्ड संख्या 7 अंक (न्यूनतम) होनी चाहिए और Luhn चेक को पास करना होगा। "प्रमाण" की कोई आवश्यकता नहीं है कि मास्टरकार्ड संख्या में 16 अंकों के अलावा कुछ भी नहीं है; बिंदु यह है कि आज की स्थिति की परवाह किए बिना, भविष्य में वे 17 या 18 अंकों के साथ कार्ड जारी कर सकते हैं, या उस मामले के लिए कुछ 15. 15. उन पर भरोसा करते हुए 16 अंक लंबा होना अनावश्यक है और एक दीर्घकालिक रखरखाव जोखिम पैदा करता है।
— एलेस्टेयर
3
मुझे यह विश्वास करना बहुत मुश्किल है कि कुछ वैध कार्डों में Luhn एल्गोरिथ्म के अनुसार सही चेक अंक नहीं होगा। यह सरल टाइपो और गूंगा धोखाधड़ी के प्रयासों के खिलाफ कार्ड नंबर की जांच करने के लिए हर जगह बिल्कुल इस्तेमाल करता है। इसके बजाय, मैंने कुछ काफी स्मार्ट लोगों को देखा है जो कि एल्गोरिथ्म को समझ नहीं पाते हैं, और वे इसे गलत मानते हैं।
— रेनेक्स
74

जावास्क्रिप्ट में:

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

अध्याय परीक्षा:

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]);
            });
        });
    });
});
— अनातोलीय
स्रोत
1
@ jolly.exe - आपकी फ़ाइडल सभी परीक्षणों के लिए अपरिभाषित है। काम नहीं करता है :(
— ShadeTreeDeveloper
@ShadeTreeDeveloper बस किसी भी मूल्य जैसे दर्ज करें। 372176090165471 पाठ क्षेत्र में AMAX के लिए
— कोड जासूस
@ jolly.exe मैं देख रहा हूं ... मैं कुछ ऐसा करने की उम्मीद कर रहा था जो मुझे टाइप करेगा (कीप इवेंट से)। जब मैं एक पूर्ण संख्या दर्ज करता हूं तो फिडल काम करता है।
— ShadeTreeDeveloper
मैंने इनपुट स्वरूपण और सत्यापन जो मैं चाहता था, करने के लिए इस बिट कोड को लिखना समाप्त कर दिया। quercusv.github.io/smartForm
— ShadeTreeDeveloper
क्या आप जानते हैं कि वी-पे और बैनकॉन्टैक्ट कार्ड नंबर का पता कैसे लगाया जाता है? धन्यवाद
— ऑलेक्ज़ेंडर आईवाई
38

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

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

JCB के ^(?: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, 309, 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

Maestro ^(5[06789]|6)[0-9]{0,}$ Maestro हमेशा रेंज में बढ़ रहा है: 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 इस फ़ंक्शन का उपयोग करने के लिए, यह कुछ उप VISA / MC कार्डों का भी पता लगाता है:

/**
  * Obtain a brand constant from a PAN
  *
  * @param string $pan               Credit card number
  * @param bool   $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
}
— जानोस सजबो
स्रोत
1
और कृपया ध्यान दें, यह केवल सीसी नंबर का पता लगाने के लिए है और सत्यापन नहीं है। यह अलग हो गया है, एक Luhn जाँच होनी चाहिए ...
— Janos Szabo
वीज़ा इलेक्ट्रॉन कहां है, और मेस्ट्रो चेक मास्टरकार्ड को कुछ मामलों में क्यों लौटाता है? मास्टरकार्ड की जाँच नहीं करनी चाहिए?
— BadHorsie
यह इस जेसीबी टेस्ट नंबर को किसी भी प्रकार (3088514174175777) के रूप में पहचानने में विफल रहता है, और इस परीक्षण जेसीबी नंबर को डाइनर्स_क्लब (3096278649822922) के रूप में पहचानता है। यह मानते हुए कि परीक्षण कार्ड नंबरों की सूची वैसे भी वैध है ( freeformatter.com/credit-card-number-generator-validator.html )
— ड्रू
कोई दस्तावेज नहीं है कि 308 या 309 शुरू करने से जेसीबी कार्ड हो सकता है
— Janos Szabo
+1 cc टाइप डिटेक्शन कोड प्रदान करने के लिए, जो आप आम तौर पर ux के लिए करना चाहते हैं - MC पर नई रेंज के लिए regex को एक छोटे ट्वीक की आवश्यकता है: / ^ (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,} $ /
— किनाकुटा
21 
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";
}

यहाँ Regex, c # का उपयोग करके क्रेडिट कार्ड के प्रकार की जाँच करने का कार्य है

— उस्मान यूनुस
स्रोत
19

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

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;
}
— Rashy
स्रोत
15

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

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

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

इसलिए हमारे पास अधिकांश उपयोग किए गए कार्ड के लिए अगले नियम हैं

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

}

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

अपडेट करें

नियमों की अद्यतन सूची यहां देखी जा सकती है https://raw.githubusercontent.com/Fivell/credit_card_validations/master/lib/data/brands.yaml

— Fivell
स्रोत
2
बहुत सचित्र। VISA कार्ड 13 अंक लंबे हो सकते हैं।
— हरमन कान
@ हरमन, कोई वीज़ा वेबसाइट नहीं कहती है कि इसकी लंबाई 16 होनी चाहिए, मुझे लगता है कि बहुत समय पहले यह 13 हो सकती थी, लेकिन आजकल नहीं
— फाइव जूल
1
मुझे लगता है कि यह विरासत का समर्थन है
— फाइव
1
@ हरमन, एक और बात है, VISA में VPay कार्ड हैं और विकिपीडिया के VPay ब्रांड के लिए accroding पैन की लंबाई को 13 से 19 अंकों तक निर्दिष्ट कर सकता है इसलिए 16 अंकों से अधिक के कार्ड नंबर अब देखे जाते हैं।
— फाइव
1
@ ईथन, मेरे अद्यतित उत्तर में अंतिम लिंक की जाँच करें कच्चा। githubusercontent.com/Fivell/credit_card_validations/master/…
— पाँच
13

यहाँ पर सभी तरह की CC संबंधित चीजों के लिए पूरा C # या VB कोड है ।

  • IsValidNumber
  • GetCardTypeFromNumber
  • GetCardTestNumber
  • PassesLuhnTest

इस लेख को कुछ वर्षों के लिए किया गया है जिसमें कोई नकारात्मक टिप्पणी नहीं है।

— Simon_Weaver
स्रोत
1
@barett - इसे ठीक किया। ऐसा लगता है कि उन्होंने इसे 'एस्पनेट' श्रेणी से 'सत्यापन' श्रेणी में स्थानांतरित कर दिया है, जिसने लिंक को बदल दिया
— सिमोन_विवर
2
लिंक टूट गया है। शायद यह वही उपयोगिता है? codeproject.com/Articles/20271/…
— जोश नूर
यह कोडप्रोजेक्ट कोड 2007 से है। चेतावनी, यह पुराना हो सकता है।
— एरन
8

कॉम्पैक्ट जावास्क्रिप्ट संस्करण

    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;
            }
        }
    };
— छेद
स्रोत
8

अनातोली का 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;
    }
 }
— angelcool.net
स्रोत
7

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

<?php
class CreditcardType
{
    public static $creditcardTypes = [
        [
            'Name' => 'American Express',
            'cardLength' => [15],
            'cardPrefix' => ['34', '37'],
        ], [
            'Name' => 'Maestro',
            'cardLength' => [12, 13, 14, 15, 16, 17, 18, 19],
            'cardPrefix' => ['5018', '5020', '5038', '6304', '6759', '6761', '6763'],
        ], [
            'Name' => 'Mastercard',
            'cardLength' => [16],
            'cardPrefix' => ['51', '52', '53', '54', '55'],
        ], [
            'Name' => 'Visa',
            'cardLength' => [13, 16],
            'cardPrefix' => ['4'],
        ], [
            'Name' => 'JCB',
            'cardLength' => [16],
            'cardPrefix' => ['3528', '3529', '353', '354', '355', '356', '357', '358'],
        ], [
            'Name' => 'Discover',
            'cardLength' => [16],
            'cardPrefix' => ['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'],
        ], [
            'Name' => 'Solo',
            'cardLength' => [16, 18, 19],
            'cardPrefix' => ['6334', '6767'],
        ], [
            'Name' => 'Unionpay',
            'cardLength' => [16, 17, 18, 19],
            'cardPrefix' => ['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'],
        ], [
            'Name' => 'Diners Club',
            'cardLength' => [14],
            'cardPrefix' => ['300', '301', '302', '303', '304', '305', '36'],
        ], [
            'Name' => 'Diners Club US',
            'cardLength' => [16],
            'cardPrefix' => ['54', '55'],
        ], [
            'Name' => 'Diners Club Carte Blanche',
            'cardLength' => [14],
            'cardPrefix' => ['300', '305'],
        ], [
            'Name' => 'Laser',
            'cardLength' => [16, 17, 18, 19],
            'cardPrefix' => ['6304', '6706', '6771', '6709'],
        ],
    ];

    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;
    }
}
— इस्माइल
स्रोत
6

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

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

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

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

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

— Gajus
स्रोत
1
यह बस असत्य है। मुझे 3 अलग-अलग प्रदाताओं के बारे में पता है, जिनके लिए कार्ड प्रकारों को पारित करने की आवश्यकता होती है, और यदि आप इसे पास नहीं करते हैं, तो लेनदेन विफल हो जाएगा।
— एड डिग्वेन
3
@EdDeGagne - "परवाह नहीं करता कि क्या मूल्य" उसी तरह नहीं है जैसे "पास होने पर परवाह नहीं करता"।
— क्वेंटिन स्कूसन
मैंने कहां निर्दिष्ट किया? मैंने केवल उल्लेख किया है कि ऐसे प्रदाता हैं जो आपको सीसी प्रकार में उत्तीर्ण करने की आवश्यकता है, इससे अधिक कुछ नहीं।
— एड डेग्वेन
आप इस जटिल मुद्दे को सरल नहीं कर सकते हैं, लेकिन आमतौर पर भुगतान प्रदाताओं को आपके लिए कार्ड के प्रकार का सुझाव देने की आवश्यकता नहीं होती है, उनके पास पता लगाने की अपनी विधि है
— Janos Szabo
6

वेंडर को अनुमानित करने के लिए क्रेडिट कार्ड की पहली संख्या का उपयोग किया जा सकता है:

  • वीजा: 49,44 या 47
  • वीज़ा इलेक्ट्रॉन: 42, 45, 48, 49
  • मास्टरकार्ड: 51
  • एमेक्स: 34
  • डिनर: 30, 36, 38
  • JCB: 35
— Shoban
स्रोत
इन श्रेणियों को प्रमुख रूप से अपडेट किया गया है, कार्ड विक्रेता कंपनियों ने पोस्ट में उल्लिखित की तुलना में अधिक श्रेणियों को जोड़ा है।
— NJInamdar
6

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

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

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

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

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

— माइकरोगर
स्रोत
हाय @CaiqueOliveira, अद्यतन लिंक देखें। Mac9416 के लिए धन्यवाद जिन्होंने अद्यतन बिन-नियम संदर्भ के लिए एक लिंक प्रदान किया।
— माइकरोगर
1
धन्यवाद BIN- नियम अद्यतन के लिए @ mac9416, धन्यवाद।
— माइकरोगर
5

उस्मान वाई के उत्तर की स्विफ्ट 2.1 संस्करण। कुछ स्ट्रिंग मान द्वारा कॉल को सत्यापित करने के लिए एक प्रिंट स्टेटमेंट का उपयोग करें

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

}
— डेज़ी आर।
स्रोत
4

स्ट्राइप ने कार्ड योजना का पता लगाने के लिए यह शानदार जावास्क्रिप्ट लाइब्रेरी प्रदान की है । मुझे कुछ कोड स्निपेट जोड़ने दें और आपको बताएं कि इसका उपयोग कैसे करना है।

सबसे पहले इसे अपने वेब पेज पर शामिल करें

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

कार्ड स्कीम का पता लगाने के लिए दूसरी तरह से फ़ंक्शन कार्ड टाइप का उपयोग करें।

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

अधिक उदाहरण और डेमो के लिए संदर्भ लिंक यहां दिए गए हैं।

  1. Jquery.payment.js के लिए धारी ब्लॉग
  2. गितुब भंडार
— NJInamdar
स्रोत
4

स्विफ्ट में आप क्रेडिट कार्ड के प्रकार का पता लगाने के लिए एक एनम बना सकते हैं।

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

विधि को बुलाएं

— Vidyalaxmi
स्रोत
3

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 लौटाया जाता है, तो क्रेडिट कार्ड का प्रकार अनिर्धारित होता है।

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

— ZurabWeb
स्रोत
1
मौजूदा उत्तरों की भिन्नता।
— गजस
1
हां, मैंने उपरोक्त उत्तरों से कोड का उपयोग किया, इसे इम्पोर्ट किया और यहां पोस्ट किया।
— डाउनवोट
3
आपके पास (ए) मौजूदा कोड में सुधार के रूप में यह सुझाव दिया जाना चाहिए, (बी) ने उचित योगदान लिखा है, या (ग) उन स्रोतों का संदर्भ दें जिन्हें आपने नियमित अभिव्यक्ति लिखने के लिए उपयोग किया है।
— गजस
1
गजस, मेरा मानना ​​है कि मैंने समुदाय की मदद की जिस तरह से मैं उस समय कर सकता था, कृपया मुझे यह बताना बंद करें कि मुझे किसी के लिए कुछ करना चाहिए था। मैंने वह किया जो मैं मददगार हो सकता था।
— ZurabWeb 15
3

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

var sf = smartForm.formatCC(myInputString);
var cardType = sf.cardType;
— ShadeTreeDeveloper
स्रोत
2 
// 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
       },
— परवेज
स्रोत
प्रश्न क्रेडिट कार्ड की जांच करने के लिए एल्गोरिदम के बारे में है , न कि एक विशिष्ट कार्यान्वयन के लिए। यह कोड क्या करता है?
— एमिल विक्रोस्टम
2

बस एक छोटा चम्मच खिला:

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

        }

    });
— चुटकी
स्रोत
2

यहाँ पायथन में लिखे गए कुछ बूलियन फ़ंक्शंस का एक उदाहरण है कि Trueयदि कार्ड को फ़ंक्शन के नाम के अनुसार पता लगाया जाता है।

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
— radtek
स्रोत
1

कार्ड संख्या के पहले छह अंक (प्रारंभिक MII अंक सहित) को जारीकर्ता पहचान संख्या (IIN) के रूप में जाना जाता है । ये कार्ड जारी करने वाले संस्थान की पहचान करते हैं जो कार्ड धारक को कार्ड जारी करता है। शेष संख्या कार्ड जारीकर्ता द्वारा आवंटित की जाती है। कार्ड नंबर की लंबाई इसके अंकों की संख्या है। कई कार्ड जारीकर्ता अपने कार्ड पर संपूर्ण आईआईएन और खाता संख्या प्रिंट करते हैं।

उपरोक्त तथ्यों के आधार पर मैं कार्ड ब्रांड की पहचान करने के लिए JAVA कोड का एक स्निपेट रखना चाहूंगा ।

नमूना कार्ड के प्रकार

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

कार्ड उपसर्ग

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

यह देखने के लिए जांचें कि इनपुट नंबर में कोई उपसर्ग है या नहीं।

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

अंत में, उपयोगिता विधि

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

संदर्भ

— अनूप एम
स्रोत
1

कोटलिन के लिए यह प्रयास करें। रेगेक्स जोड़ें और जब बयान में जोड़ें।

private fun getCardType(number: String): String {

        val visa = Regex("^4[0-9]{12}(?:[0-9]{3})?$")
        val mastercard = Regex("^5[1-5][0-9]{14}$")
        val amx = Regex("^3[47][0-9]{13}$")

        return when {
            visa.matches(number) -> "Visa"
            mastercard.matches(number) -> "Mastercard"
            amx.matches(number) -> "American Express"
            else -> "Unknown"
        }
    }
— OhhhThatVarun
स्रोत
0

नियमित अभिव्यक्ति नियम जो संबंधित कार्ड विक्रेताओं से मेल खाते हैं :

  • (4\d{12}(?:\d{3})?) VISA के लिए।
  • (5[1-5]\d{14}) मास्टरकार्ड के लिए।
  • (3[47]\d{13}) AMEX के लिए।
  • ((?:5020|5038|6304|6579|6761)\d{12}(?:\d\d)?) Maestro के लिए।
  • (3(?:0[0-5]|[68][0-9])[0-9]{11}) डिनर क्लब के लिए।
  • (6(?:011|5[0-9]{2})[0-9]{12}) डिस्कवर के लिए।
  • (35[2-8][89]\d\d\d{10}) जेसीबी के लिए।
— राजन
स्रोत
मुझे लगता है कि जेसीबी के लिए regex गलत है। 3528 और 3589 के बीच पहले चार अंकों को स्वीकार किया जाना चाहिए, लेकिन 3570 उदाहरण के लिए नहीं है।
— गाबे
0

मैं उपयोग करता हूं नंबर से क्रेडिट कार्ड प्रकार का पता लगाने के https://github.com/bendrucker/creditcards-types/ का । एक मुद्दा जो मैंने चलाया था, वह है परीक्षण संख्या 6011 1111 1111 1117

से https://www.cybersource.com/developers/other_resources/quick_references/test_cc_numbers/ हम इसे एक नंबर की खोज है, क्योंकि यह 6011. से शुरू होता है लेकिन परिणाम मैं creditcards-प्रकार से मिलता है "Maestro" देख सकते हैं। मैंने इस मुद्दे को लेखक के लिए खोल दिया। उसने मुझे बहुत जल्द जवाब दिया और यह pdf doc https://www.discovernetwork.com/downloads/IPP_VAR_Compliance.pdf प्रदान करता है। डॉक्टर से हम स्पष्ट रूप से देख सकते हैं कि 6011 1111 1111 1117 खोज क्रेडिट कार्ड की श्रेणी में नहीं आता है।

— yuxiaomin
स्रोत
Im एक ही मुद्दा रहा है, आप इस तय हो गई?
— lucasvm1980 13
@ lucasvm1980 मुझे लगता है कि searchnetwork.com पीडीएफ फाइल अधिक विश्वसनीय है। और संख्या 6011 1111 1111 1117 केवल एक परीक्षण संख्या है, किसी भी वास्तविक क्रेडिट कार्ड में यह संख्या नहीं है। इसलिए मुझे लगता है कि इस बारे में चिंता करने की कोई जरूरत नहीं है।
— yuxiaomin
ऐसा लगता है कि कुछ डिस्कवर कार्ड के साथ कुछ बग है, मैंने वैध संख्या की कोशिश की है और मुझे वह त्रुटि भी मिल रही है।
— lucasvm1980
@ lucasvm1980 क्या आप नंबर प्रदान कर सकते हैं और गितुब पर एक मुद्दा प्रस्तुत कर सकते हैं?
— yuxiaomin
0

यह कोशिश करो। तेजी से।

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
}

उपयोग।

if (self.checkCardValidation(number: "yourNumber") == true) {
     print("Card Number valid")
}else{
     print("Card Number not valid")
}
— दीक्षित अकबरी
स्रोत
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) {

            }
        });
— गौरव गुप्ता
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.