दिलचस्प पोस्ट
for..in और hasOwnProperty दो mysqli क्वेरी लूप से एजेक्स कॉलबैक फ़ंक्शन (जावास्क्रिप्ट) के लिए इंडेक्स गुजर रहा है किसी विशिष्ट `इनलाइन-ब्लॉक` आइटम के बाद / पहले सीएसएस को लाइन ब्रेक विंडोज में कर्सर के नीचे शब्द कैसे प्राप्त करें? सी ++ में सरणियों या std :: vectors का उपयोग करना, प्रदर्शन अंतर क्या है? प्रमाणीकरण के लिए मत पूछने के लिए, Git क्लाइंट को कॉन्फ़िगर करें, जैसे कि विंडोज के लिए GitHub क्या नये सी ++ 11 प्रोग्रामों के लिए पिछला रिटर्न टाइप वाक्यविन्यास शैली डिफ़ॉल्ट होनी चाहिए? INotifyPropertyChanged प्रॉपर्टी नाम – हार्डकोड बनाम प्रतिबिंब? <Mvc: annotation-driven /> और <context: annotation-config /> servlet में अंतर के बीच क्या है? क्या सीएसएस सामग्री पर .html दस्तावेज़, या .html टुकड़ा प्रदर्शित करना संभव है? लॉन्च असफल बाइनरी नहीं मिला ई के लिए ग्रहण सी में टीएलएस / एलडीएपी या टीएलएस / एचटीटीपी कनेक्शन की स्थापना के समय तार पर क्या होता है? ब्राउज़र से पता बार हटाना (एंड्रॉइड पर देखने के लिए) MySQLi mysql_result () के बराबर?

आरजीबी हेक्स और हेक्स से आरजीबी तक

आरजीबी प्रारूप में रंगों को हेक्स प्रारूप में परिवर्तित करने के लिए और इसके विपरीत कैसे करें?

उदाहरण के लिए, '#0080C0' को (0, 128, 192) कनवर्ट करें।

वेब के समाधान से एकत्रित समाधान "आरजीबी हेक्स और हेक्स से आरजीबी तक"

निम्नलिखित आरजीबी को हेक्स रूपांतरण के लिए कर देगा और आवश्यक शून्य पैडिंग जोड़ देगा:

 function componentToHex(c) { var hex = c.toString(16); return hex.length == 1 ? "0" + hex : hex; } function rgbToHex(r, g, b) { return "#" + componentToHex(r) + componentToHex(g) + componentToHex(b); } alert( rgbToHex(0, 51, 255) ); // #0033ff 

अन्य तरीका परिवर्तित करना:

 function hexToRgb(hex) { var result = /^#?([af\d]{2})([af\d]{2})([af\d]{2})$/i.exec(hex); return result ? { r: parseInt(result[1], 16), g: parseInt(result[2], 16), b: parseInt(result[3], 16) } : null; } alert( hexToRgb("#0033ff").g ); // "51"; 

अंत में, rgbToHex() का एक वैकल्पिक संस्करण, जैसा कि @ कैसाब्लांका के उत्तर में चर्चा की गई और @कॉल्व्स द्वारा टिप्पणियों में सुझाई गई:

 function rgbToHex(r, g, b) { return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1); } 

3 दिसंबर 2012 को अपडेट करें

यहां hexToRgb() का एक संस्करण है जो "# 03 एफ" जैसे एक लघुकोड हेक्स त्रिपाठी भी पार्स करता है:

 function hexToRgb(hex) { // Expand shorthand form (eg "03F") to full form (eg "0033FF") var shorthandRegex = /^#?([af\d])([af\d])([af\d])$/i; hex = hex.replace(shorthandRegex, function(m, r, g, b) { return r + r + g + g + b + b; }); var result = /^#?([af\d]{2})([af\d]{2})([af\d]{2})$/i.exec(hex); return result ? { r: parseInt(result[1], 16), g: parseInt(result[2], 16), b: parseInt(result[3], 16) } : null; } alert( hexToRgb("#0033ff").g ); // "51"; alert( hexToRgb("#03f").g ); // "51"; 

हेक्सटोरगबी का एक वैकल्पिक संस्करण:

 function hexToRgb(hex) { var bigint = parseInt(hex, 16); var r = (bigint >> 16) & 255; var g = (bigint >> 8) & 255; var b = bigint & 255; return r + "," + g + "," + b; } 

संपादित करें: 3/28/2017 यहां एक और दृष्टिकोण है जो अभी भी तेज़ हो रहा है

 function hexToRgbNew(hex) { var arrBuff = new ArrayBuffer(4); var vw = new DataView(arrBuff); vw.setUint32(0,parseInt(hex, 16),false); var arrByte = new Uint8Array(arrBuff); return arrByte[1] + "," + arrByte[2] + "," + arrByte[3]; } 

संपादित करें: 8/11/2017 अधिक परीक्षण के बाद उपरोक्त नया दृष्टिकोण तेजी से नहीं है 🙁 हालांकि यह एक मजेदार वैकल्पिक तरीका है।

यहां मेरा संस्करण है:

  function rgb2hex(red, green, blue) { var rgb = blue | (green << 8) | (red << 16); return '#' + (0x1000000 + rgb).toString(16).slice(1) } function hex2rgb(hex) { // long version r = hex.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i); if (r) { return r.slice(1,4).map(function(x) { return parseInt(x, 16); }); } // short version r = hex.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i); if (r) { return r.slice(1,4).map(function(x) { return 0x11 * parseInt(x, 16); }); } return null; } 

मैं मान रहा हूँ कि आप HTML- शैली हेक्साडेसिमल अंकन, अर्थात # #rrggbb । आपका कोड लगभग सही है, सिवाय इसके कि आपके पास क्रम उलटा हुआ है। यह होना चाहिए:

 var decColor = red * 65536 + green * 256 + blue; 

इसके अलावा, बिट-शिफ्ट का उपयोग करके इसे पढ़ने में थोड़ा आसान हो सकता है:

 var decColor = (red << 16) + (green << 8) + blue; 

यह कोड #fff और #ffffff वेरिएंट और अस्पष्टता स्वीकार करते हैं

 function hex2rgb(hex, opacity) { var h=hex.replace('#', ''); h = h.match(new RegExp('(.{'+h.length/3+'})', 'g')); for(var i=0; i<h.length; i++) h[i] = parseInt(h[i].length==1? h[i]+h[i]:h[i], 16); if (typeof opacity != 'undefined') h.push(opacity); return 'rgba('+h.join(',')+')'; } 
 function hex2rgb(hex) { return ['0x' + hex[1] + hex[2] | 0, '0x' + hex[3] + hex[4] | 0, '0x' + hex[5] + hex[6] | 0]; } 

टिम डाउन के जवाब के ईसीएमएस्क्रिप्ट 6 संस्करण

आरजीबी हेक्स को परिवर्तित करना

 const rgbToHex = (r, g, b) => '#' + [r, g, b].map(x => { const hex = x.toString(16) return hex.length === 1 ? '0' + hex : hex }).join('') console.log(rgbToHex(0, 51, 255)); // '#0033ff' 

आरजीबीए के लिए एक-लाइन कार्यात्मक हेक्स

दोनों लघु #ffffff और लम्बी #ffffff फॉर्म का समर्थन करता है।
अल्फा चैनल (अस्पष्टता) का समर्थन करता है
हैश निर्दिष्ट या नहीं, परवाह नहीं है, दोनों मामलों में काम करता है।

 function hexToRGBA(hex, opacity) { return 'rgba(' + (hex = hex.replace('#', '')).match(new RegExp('(.{' + hex.length/3 + '})', 'g')).map(function(l) { return parseInt(hex.length%2 ? l+l : l, 16) }).concat(opacity||1).join(',') + ')'; } 

उदाहरण:

 hexToRGBA('#fff') -> rgba(255,255,255,1) hexToRGBA('#ffffff') -> rgba(255,255,255,1) hexToRGBA('#fff', .2) -> rgba(255,255,255,0.2) hexToRGBA('#ffffff', .2) -> rgba(255,255,255,0.2) hexToRGBA('fff', .2) -> rgba(255,255,255,0.2) hexToRGBA('ffffff', .2) -> rgba(255,255,255,0.2) 

// एचएसएल नोटेशन की उपेक्षा करना, रंग मान को आम तौर पर नाम, आरजीबी, आरजीबीए या हेक्स-

// हेक्स 3 मान या 6 हो सकते हैं

// आरजीबी प्रतिशत और साथ ही पूर्णांक मान भी हो सकते हैं।

// इन सभी प्रारूपों के लिए सर्वश्रेष्ठ खाते, कम से कम

 String.prototype.padZero= function(len, c){ var s= this, c= c || "0", len= len || 2; while(s.length < len) s= c + s; return s; } var colors={ colornames:{ aqua: '#00ffff', black: '#000000', blue: '#0000ff', fuchsia: '#ff00ff', gray: '#808080', green: '#008000', lime: '#00ff00', maroon: '#800000', navy: '#000080', olive: '#808000', purple: '#800080', red: '#ff0000', silver: '#c0c0c0', teal: '#008080', white: '#ffffff', yellow: '#ffff00' }, toRgb: function(c){ c= '0x'+colors.toHex(c).substring(1); c= [(c>> 16)&255, (c>> 8)&255, c&255]; return 'rgb('+c.join(',')+')'; }, toHex: function(c){ var tem, i= 0, c= c? c.toString().toLowerCase(): ''; if(/^#[a-f0-9]{3,6}$/.test(c)){ if(c.length< 7){ var A= c.split(''); c= A[0]+A[1]+A[1]+A[2]+A[2]+A[3]+A[3]; } return c; } if(/^[az]+$/.test(c)){ return colors.colornames[c] || ''; } c= c.match(/\d+(\.\d+)?%?/g) || []; if(c.length<3) return ''; c= c.slice(0, 3); while(i< 3){ tem= c[i]; if(tem.indexOf('%')!= -1){ tem= Math.round(parseFloat(tem)*2.55); } else tem= parseInt(tem); if(tem< 0 || tem> 255) c.length= 0; else c[i++]= tem.toString(16).padZero(2); } if(c.length== 3) return '#'+c.join('').toLowerCase(); return ''; } } //var c='#dc149c'; //var c='rgb(100%,25%,0)'; // var c= 'red'; alert(colors.toRgb(c)+'\n'+colors.toHex(c)); 

@ टिम, आपके उत्तर में जोड़ने के लिए (यह एक टिप्पणी में थोड़ा अजीब है)।

लिखित रूप में, मैंने पाया कि आरजीबीटोएक्स फ़ंक्शन बिंदु के बाद तत्वों के साथ एक स्ट्रिंग देता है और इसकी आवश्यकता है कि r, g, b मान सीमा 0-255 के भीतर आते हैं

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

 function rgbToHex(r, g, b) { if(r < 0 || r > 255) alert("r is out of bounds; "+r); if(g < 0 || g > 255) alert("g is out of bounds; "+g); if(b < 0 || b > 255) alert("b is out of bounds; "+b); return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1,7); } 

यह गणना की गई शैली के तरीकों से रंग पाने के लिए इस्तेमाल किया जा सकता है:

 function rgbToHex(color) { color = ""+ color; if (!color || color.indexOf("rgb") < 0) { return; } if (color.charAt(0) == "#") { return color; } var nums = /(.*?)rgb\((\d+),\s*(\d+),\s*(\d+)\)/i.exec(color), r = parseInt(nums[2], 10).toString(16), g = parseInt(nums[3], 10).toString(16), b = parseInt(nums[4], 10).toString(16); return "#"+ ( (r.length == 1 ? "0"+ r : r) + (g.length == 1 ? "0"+ g : g) + (b.length == 1 ? "0"+ b : b) ); } // not computed <div style="color: #4d93bc; border: 1px solid red;">...</div> // computed <div style="color: rgb(77, 147, 188); border: 1px solid rgb(255, 0, 0);">...</div> console.log( rgbToHex(color) ) // #4d93bc console.log( rgbToHex(borderTopColor) ) // #ff0000 

रेफरी: https://github.com/k-gun/so/blob/master/so_util.js#L43

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

  var canvas = document.createElement("canvas"); var ctx = this.canvas.getContext('2d'); ctx.fillStyle = "rgb(pass,some,value)"; var temp = ctx.fillStyle; ctx.fillStyle = "someColor"; alert(ctx.fillStyle == temp); 

क्या आप ऐसा कुछ के बाद हो सकते हैं?

 function RGB2HTML(red, green, blue) { return '#' + red.toString(16) + green.toString(16) + blue.toString(16); } alert(RGB2HTML(150, 135, 200)); 

प्रदर्शित करता है # 9687c8

टिम डाउन के 3 अंकों के हेक्साटोआरजीबी फ़ंक्शन के लिए नीचे के रूप में सुधार किया जा सकता है:

 var hex2Rgb = function(hex){ var result = /^#?([af\d]{2})([af\d]{2})([af\d]{2})|([af\d]{1})([af\d]{1})([af\d]{1})$/i.exec(hex); return result ? { r: parseInt(hex.length <= 4 ? result[4]+result[4] : result[1], 16), g: parseInt(hex.length <= 4 ? result[5]+result[5] : result[2], 16), b: parseInt(hex.length <= 4 ? result[6]+result[6] : result[3], 16), toString: function() { var arr = []; arr.push(this.r); arr.push(this.g); arr.push(this.b); return "rgb(" + arr.join(",") + ")"; } } : null; }; 

(2017) सरल ES6 कंपोज़ योग्य तीर फ़ंक्शन

मैं उन लोगों के लिए यह साझा नहीं कर सकता जो ईएस 6 का उपयोग करते हुए कुछ आधुनिक कार्यात्मक / रचनात्मक जेएस लिख रहे हैं। यहाँ कुछ चालाक एक-लाइनर्स हैं जो मैं एक रंग मॉड्यूल में उपयोग कर रहा हूं जो डेटा विज़ुअलाइज़ेशन के लिए रंग प्रक्षेप करता है।

ध्यान दें कि यह अल्फा चैनल बिल्कुल भी नहीं संभालता है

 const arrayToRGBString = rgb => `rgb(${rgb.join(',')})`; const hexToRGBArray = hex => hex.match(/[A-Za-z0-9]{2}/g).map(v => parseInt(v, 16)); const rgbArrayToHex = rgb => `#${rgb.map(v => v.toString(16).padStart(2, '0')).join('')}`; const rgbStringToArray = rgb => rgb.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/).splice(1, 3) .map(v => Number(v)); const rgbStringToHex = rgb => rgbArrayToHex(rgbStringToArray(rgb)); 

मुझे ऐसे फ़ंक्शन की आवश्यकता है जो अमान्य मान भी स्वीकार करते हैं

आरजीबी (-255, 255, 255) आरजीबी (510, 255, 255)

यह @cwolves उत्तर का एक स्पिन है I

 function rgb(r, g, b) { this.c = this.c || function (n) { return Math.max(Math.min(n, 255), 0) }; return ((1 << 24) + (this.c(r) << 16) + (this.c(g) << 8) + this.c(b)).toString(16).slice(1).toUpperCase(); } 

हेक्स 2 आरबीजी का मेरा संस्करण:

  1. # एफएफएफ की तरह कम हेक्स स्वीकार करें
  2. एल्गोरिथ्म कम्पैसिटी ओ (एन) है, तो तेजी से फिर से regex का उपयोग करना चाहिए। जैसे String.replace, String.split, String.match आदि।
  3. स्थिर स्थान का उपयोग करें
  4. समर्थन आरजीबी और आरजीबीए

यदि आप IE8 का उपयोग कर रहे हैं, तो आपको हेक्स.ट्रिम () निकालने की आवश्यकता हो सकती है।

जैसे

 hex2rgb('#fff') //rgb(255,255,255) hex2rgb('#fff', 1) //rgba(255,255,255,1) hex2rgb('#ffffff') //rgb(255,255,255) hex2rgb('#ffffff', 1) //rgba(255,255,255,1) 

कोड:

 function hex2rgb (hex, opacity) { hex = hex.trim(); hex = hex[0] === '#' ? hex.substr(1) : hex; var bigint = parseInt(hex, 16), h = []; if (hex.length === 3) { h.push((bigint >> 4) & 255); h.push((bigint >> 2) & 255); } else { h.push((bigint >> 16) & 255); h.push((bigint >> 8) & 255); } h.push(bigint & 255); if (arguments.length === 2) { h.push(opacity); return 'rgba('+h.join()+')'; } else { return 'rgb('+h.join()+')'; } } 

मैं इस समस्या के कारण आया था क्योंकि मैं किसी रंग के मूल्य को स्वीकार करना और अस्पष्टता को जोड़ना चाहता था, इसलिए मैंने इस त्वरित jQuery प्लगइन को आधुनिक ब्राउज़रों पर मूल कैनवास का उपयोग किया। सिर्फ महान काम करने के लिए लगता है

संपादित करें

बाहर निकलता है मैं समझ नहीं सकता कि यह कैसे एक उचित jQuery प्लगिन बनाने के लिए है, इसलिए मैं इसे नियमित फ़ंक्शन के रूप में पेश करूंगा।

 //accepts any value like '#ffffff', 'rgba(255,255,255,1)', 'hsl(0,100%,100%)', or 'white' function toRGBA( c ) { var can = document.createElement( 'canvas' ), ctx = can.getContext( '2d' ); can.width = can.height = 1; ctx.fillStyle = c; console.log( ctx.fillStyle ); //always css 6 digit hex color string, eg '#ffffff' ctx.fillRect( 0, 0, 1, 1 ); //paint the canvas var img = ctx.getImageData( 0, 0, 1, 1 ), data = img.data, rgba = { r: data[ 0 ], //0-255 red g: data[ 1 ], //0-255 green b: data[ 2 ], //0-255 blue a: data[ 3 ] //0-255 opacity (0 being transparent, 255 being opaque) }; return rgba; }; 
 R = HexToR("#FFFFFF"); G = HexToG("#FFFFFF"); B = HexToB("#FFFFFF"); function HexToR(h) {return parseInt((cutHex(h)).substring(0,2),16)} function HexToG(h) {return parseInt((cutHex(h)).substring(2,4),16)} function HexToB(h) {return parseInt((cutHex(h)).substring(4,6),16)} function cutHex(h) {return (h.charAt(0)=="#") ? h.substring(1,7):h} 

किसी भी मुद्दे के बिना परिणाम प्राप्त करने के लिए इन फ़ंक्शन का उपयोग करें 🙂

मैं XAML डेटा के साथ काम कर रहा हूं जिसमें # एएआरआरजीजीबीबी (अल्फा, रेड, ग्रीन, ब्लू) के हेक्स प्रारूप है। ऊपर दिए गए उत्तर का उपयोग करना, यहां मेरा समाधान है:

 function hexToRgba(hex) { var bigint, r, g, b, a; //Remove # character var re = /^#?/; var aRgb = hex.replace(re, ''); bigint = parseInt(aRgb, 16); //If in #FFF format if (aRgb.length == 3) { r = (bigint >> 4) & 255; g = (bigint >> 2) & 255; b = bigint & 255; return "rgba(" + r + "," + g + "," + b + ",1)"; } //If in #RRGGBB format if (aRgb.length >= 6) { r = (bigint >> 16) & 255; g = (bigint >> 8) & 255; b = bigint & 255; var rgb = r + "," + g + "," + b; //If in #AARRBBGG format if (aRgb.length == 8) { a = ((bigint >> 24) & 255) / 255; return "rgba(" + rgb + "," + a.toFixed(1) + ")"; } } return "rgba(" + rgb + ",1)"; } 

http://jsfiddle.net/kvLyscs3/

JQuery से सीधे परिवर्तित करने के लिए आप कोशिश कर सकते हैं:

  function rgbToHex(color) { var bg = color.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/); function hex(x) { return ("0" + parseInt(x).toString(16)).slice(-2); } return "#" + hex(bg[1]) + hex(bg[2]) + hex(bg[3]); } rgbToHex($('.col-tab-bar .col-tab span').css('color')) 

शॉर्टहैड संस्करण जो एक स्ट्रिंग स्वीकार करता है:

 function rgbToHex(a){ a=a.replace(/[^\d,]/g,"").split(","); return"#"+((1<<24)+(+a[0]<<16)+(+a[1]<<8)+ +a[2]).toString(16).slice(1) } document.write(rgbToHex("rgb(255,255,255)")); 

बहुत सारे जवाबों को ध्यान में रखते हुए केवल आंशिक रूप से सवाल का उत्तर (आरजीबी से हेक्स या अन्य तरीके से चारों ओर) मैंने सोचा कि मैं भी अपना आंशिक उत्तर पोस्ट करना चाहूंगा

मेरे पास एक समान समस्या थी और मैं ऐसा कुछ करना चाहता था: किसी भी मान्य सीएसएस रंग (एचएसएल (ए), आरजीबी (ए), हेक्स या रंग का नाम) इनपुट करें और 1. एक अल्फा मान जोड़ने या निकालने में सक्षम हो, 2 एक आरजीबी वापसी (ए) वस्तु मैंने इस उद्देश्य के लिए वास्तव में एक प्लगइन लिखा था यह GitHub पर पाया जा सकता है (यह jQuery की आवश्यकता है, लेकिन अगर आप चाहते हैं कि आप इसे कांटा और एक वेनिला संस्करण बना सकते हैं) यहां एक डेमो पेज है आप खुद के लिए कोशिश कर सकते हैं और मक्खी पर उत्पन्न उत्पादन देख सकते हैं।

मैं यहां विकल्पों को कॉपी-पेस्ट करूँगा:

आरजीबी जेनरेटर एक तर्क, रंग स्वीकार करता है, और तीन विकल्प प्रदान करता है: asObject, addAlpha और removeAlpha। जब तीन विकल्प छोड़े जाते हैं, तो आरजीबी रंग स्ट्रिंग के रूप में वापस आ जाएगा।

 $.rgbGenerator("white") // Will return rgb(255,255,255) 

ध्यान दें कि डिफ़ॉल्ट रूप से अल्फा घटकों को शामिल किया गया है। यदि इनपुट मूल्य में अल्फा मान होता है, तो आउटपुट आरजीबीए प्रारूप में होगा।

 $.rgbGenerator("hsla(0,100%,50%,0.8)") // Will return rgba(255,0,0,0.8) 

आप trueAlpha को सही पर सेट करके इस व्यवहार को अक्षम कर सकते हैं। यह प्रारंभिक एचएसएलए या आरजीबीए रंग से कोई अल्फा मान निकाल देगा।

 $.rgbGenerator("hsla(0,100%,50%,0.8)", {removeAlpha: true}) // Will return rgb(255,0,0) 

अगर, दूसरी तरफ, आप एक अल्फा चैनल जोड़ना चाहते हैं, तो आप 0 और 1 के बीच किसी भी मूल्य के लिए एडीएएलएफा सेट करके ऐसा कर सकते हैं। जब इनपुट एक गैर-पारदर्शी रंग होता है, अल्फा मान जोड़ दिया जाएगा। यदि यह एक पारदर्शी है, तो प्रदान किए गए मान इनपुट के अल्फा घटक को अधिलेखित करेगा।

 $.rgbGenerator("hsl(0,100%,50%)", {addAlpha: 0.4}) // Will return rgba(255,0,0,0.4) $.rgbGenerator("hsla(0,100%,50%,0.8)", {addAlpha: 0.4}) // Will return rgba(255,0,0,0.4) 

आखिरकार आरजीबी (ए) का रंग ऑब्जेक्ट के रूप में भी संभव है। इसमें आर, जी, बी और वैकल्पिक रूप से एक होगा।

 $.rgbGenerator("hsla(0,100%,50%,0.8)", {asObject: true}) /* Will return { "r": 255, "g": 0, "b": 0, "a": 0.8 } */ $.rgbGenerator("hsla(0,100%,50%,0.8)", {asObject: true}).r // Will return 255 

टिम डाउन द्वारा दिए गए सबसे ऊपर दिए गए उत्तर का सबसे अच्छा समाधान प्रदान करता है जिसे मैं आरजीबी में रूपांतरण के लिए देख सकता हूं। मुझे यह समाधान हेक्स रूपांतरण के लिए अच्छा लगता है, क्योंकि यह हेक्स के रूपांतरण के लिए सबसे संक्षिप्त सीमा जांच और शून्य पैडिंग प्रदान करता है।

 function RGBtoHex (red, green, blue) { red = Math.max(0, Math.min(~~this.red, 255)); green = Math.max(0, Math.min(~~this.green, 255)); blue = Math.max(0, Math.min(~~this.blue, 255)); return '#' + ('00000' + (red << 16 | green << 8 | blue).toString(16)).slice(-6); }; 

बाएं बदलाव '<<' और या '|' का प्रयोग ऑपरेटरों को यह एक मजेदार समाधान भी बनाते हैं

मैंने यह पाया और क्योंकि मुझे लगता है कि यह बहुत सीधे आगे है और सत्यापन परीक्षण और अल्फा मूल्यों (वैकल्पिक) का समर्थन करता है, यह मामला फिट होगा।

यदि आप जानते हैं कि आप क्या कर रहे हैं, तो बस रैगेक्स लाइन पर टिप्पणी करें और यह थोड़ा सा तेज है

 function hexToRGBA(hex, alpha){ hex = (""+hex).trim().replace(/#/g,""); //trim and remove any leading # if there (supports number values as well) if (!/^(?:[0-9a-fA-F]{3}){1,2}$/.test(hex)) throw ("not a valid hex string"); //Regex Validator if (hex.length==3){hex=hex[0]+hex[0]+hex[1]+hex[1]+hex[2]+hex[2]} //support short form var b_int = parseInt(hex, 16); return "rgba("+[ (b_int >> 16) & 255, //R (b_int >> 8) & 255, //G b_int & 255, //B alpha || 1 //add alpha if is set ].join(",")+")"; } 

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

ऐसा लगता है कि आप ऐसा कुछ ढूंढ रहे हैं:

 function hexstr(number) { var chars = new Array("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"); var low = number & 0xf; var high = (number >> 4) & 0xf; return "" + chars[high] + chars[low]; } function rgb2hex(r, g, b) { return "#" + hexstr(r) + hexstr(g) + hexstr(b); } 
 function hexToRgb(str) { if ( /^#([0-9a-f]{3}|[0-9a-f]{6})$/ig.test(str) ) { var hex = str.substr(1); hex = hex.length == 3 ? hex.replace(/(.)/g, '$1$1') : hex; var rgb = parseInt(hex, 16); return 'rgb(' + [(rgb >> 16) & 255, (rgb >> 8) & 255, rgb & 255].join(',') + ')'; } return false; } function rgbToHex(red, green, blue) { var out = '#'; for (var i = 0; i < 3; ++i) { var n = typeof arguments[i] == 'number' ? arguments[i] : parseInt(arguments[i]); if (isNaN(n) || n < 0 || n > 255) { return false; } out += (n < 16 ? '0' : '') + n.toString(16); } return out 

उपरोक्त का एक स्वच्छ कॉफी संस्करण (धन्यवाद @ टिमडाउन):

 rgbToHex = (rgb) -> a = rgb.match /\d+/g rgb unless a.length is 3 "##{ ((1 << 24) + (parseInt(a[0]) << 16) + (parseInt(a[1]) << 8) + parseInt(a[2])).toString(16).slice(1) }" 

मेरा बेवकूफ उदाहरण =)

 color: { toHex: function(num){ var str = num.toString(16); return (str.length<6?'#00'+str:'#'+str); }, toNum: function(hex){ return parseInt(hex.replace('#',''), 16); }, rgbToHex: function(color) { color = color.replace(/\s/g,""); var aRGB = color.match(/^rgb\((\d{1,3}[%]?),(\d{1,3}[%]?),(\d{1,3}[%]?)\)$/i); if(aRGB) { color = ''; for (var i=1; i<=3; i++) color += Math.round((aRGB[i][aRGB[i].length-1]=="%"?2.55:1)*parseInt(aRGB[i])).toString(16).replace(/^(.)$/,'0$1'); } else color = color.replace(/^#?([\da-f])([\da-f])([\da-f])$/i, '$1$1$2$2$3$3'); return '#'+color; }