Duvido que alguma coisa seja mais rápida ou mais curta que esta.

"#"+((1<<24)*Math.random()|0).toString(16)

Desafio!

Aqui está outra opinião sobre este problema. O meu objectivo era criar cores vibrantes e distintas. Para garantir que as cores são distintas Eu evitar usar um gerador aleatório e selecionar cores" uniformemente espaçadas " do arco-íris.

Isto é perfeito para criar marcadores pop-out no Google Maps que têm a "singularidade" ideal (ou seja, nenhum dois marcadores terá cores semelhantes).

function rainbow(numOfSteps, step) {
    // This function generates vibrant, "evenly spaced" colours (i.e. no clustering). This is ideal for creating easily distinguishable vibrant markers in Google Maps and other apps.
    // Adam Cole, 2011-Sept-14
    // HSV to RBG adapted from: http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
    var r, g, b;
    var h = step / numOfSteps;
    var i = ~~(h * 6);
    var f = h * 6 - i;
    var q = 1 - f;
    switch(i % 6){
        case 0: r = 1; g = f; b = 0; break;
        case 1: r = q; g = 1; b = 0; break;
        case 2: r = 0; g = 1; b = f; break;
        case 3: r = 0; g = q; b = 1; break;
        case 4: r = f; g = 0; b = 1; break;
        case 5: r = 1; g = 0; b = q; break;
    }
    var c = "#" + ("00" + (~ ~(r * 255)).toString(16)).slice(-2) + ("00" + (~ ~(g * 255)).toString(16)).slice(-2) + ("00" + (~ ~(b * 255)).toString(16)).slice(-2);
    return (c);
}

Se quiser ver como isto se parece em acção, veja em http://blog.adamcole.ca/2011/11/simple-javascript-rainbow-color.html.

Quem pode vencê-lo?

'#'+Math.random().toString(16).substr(-6);

É garantido trabalhar o tempo todo: http://jsbin.com/OjELIfo/2/edit

Com base no comentário do @eterps, o código acima ainda pode gerar cadeias de caracteres mais curtas se a representação hexadecimal da cor aleatória for muito curta (0.730224609375 => 0.baf)

Este código deve funcionar em todos os casos:

function makeRandomColor(){
  var c = '';
  while (c.length < 7) {
    c += (Math.random()).toString(16).substr(-6).substr(-1)
  }
  return '#'+c;
}

Não há necessidade de hash de letras hexadecimais. JavaScript pode fazer isso por si mesmo:

function get_random_color() {
  function c() {
    var hex = Math.floor(Math.random()*256).toString(16);
    return ("0"+String(hex)).substr(-2); // pad with zero
  }
  return "#"+c()+c()+c();
}

Gosto deste.: '#' + (Math.random().toString(16) + "000000").substring(2,8)

Geração aleatória de cores com controlo de brilho:

function getRandColor(brightness){

    // Six levels of brightness from 0 to 5, 0 being the darkest
    var rgb = [Math.random() * 256, Math.random() * 256, Math.random() * 256];
    var mix = [brightness*51, brightness*51, brightness*51]; //51 => 255/5
    var mixedrgb = [rgb[0] + mix[0], rgb[1] + mix[1], rgb[2] + mix[2]].map(function(x){ return Math.round(x/2.0)})
    return "rgb(" + mixedrgb.join(",") + ")";
}

'#'+Math.random().toString(16).slice(-3) // three-numbers format aka #f3c
'#'+Math.random().toString(16).slice(-6) // six-number format aka #abc123

Pode usar o HSL disponível em todos os bons navegadores ( http://caniuse.com/#feat=css3-colors)

function randomHsl() {
    return 'hsla(' + (Math.random() * 360) + ', 100%, 50%, 1)';
}

Isso lhe dará apenas cores brilhantes, você também pode brincar com o brilho, saturação e alfa.

// es6
const randomHsl = () => `hsla(${Math.random() * 360}, 100%, 50%, 1)`

Aqui está uma reviravolta na solução fornecida por @Anatoliy.

Eu precisava gerar apenas cores claras( para fundos), então eu fui com três letras (#AAA) formato:

function get_random_color() {
    var letters = 'ABCDE'.split('');
    var color = '#';
    for (var i=0; i<3; i++ ) {
        color += letters[Math.floor(Math.random() * letters.length)];
    }
    return color;
}

O artigo escrito por Paul Irish sobre o gerador de código de cores hex Aleatório em JavaScript é absolutamente incrível. Uso:

'#'+Math.floor(Math.random()*16777215).toString(16);

Aqui está o link de origem:

Http://www.paulirish.com/2009/random-hex-color-code-snippets/

Isto pode ser facilmente encontrado usando a pesquisa do Google:

function random_color(format)
{
    var rint = Math.round(0xffffff * Math.random());
    switch(format)
    {
        case 'hex':
            return ('#0' + rint.toString(16)).replace(/^#0([0-9a-f]{6})$/i, '#$1');
            break;

        case 'rgb':
            return 'rgb(' + (rint >> 16) + ',' + (rint >> 8 & 255) + ',' + (rint & 255) + ')';
            break;

        default:
            return rint;
            break;
    }
}

Versão actualizada:

function random_color( format ){
  var rint = Math.floor( 0x100000000 * Math.random());
  switch( format ){
    case 'hex':
      return '#' + ('00000'   + rint.toString(16)).slice(-6).toUpperCase();
    case 'hexa':
      return '#' + ('0000000' + rint.toString(16)).slice(-8).toUpperCase();
    case 'rgb':
      return 'rgb('  + (rint & 255) + ',' + (rint >> 8 & 255) + ',' + (rint >> 16 & 255) + ')';
    case 'rgba':
      return 'rgba(' + (rint & 255) + ',' + (rint >> 8 & 255) + ',' + (rint >> 16 & 255) + ',' + (rint >> 24 & 255)/255 + ')';
    default:
      return rint;
  }
}

var color = "#";
for (k = 0; k < 3; k++) {
    color += ("0" + (Math.random()*256|0).toString(16)).substr(-2);
}

Uma descrição do modo como isto funciona:

Math.random()*256 obtém um número aleatório (vírgula flutuante) de 0 a 256 (0 a 255 inclusive)
Resultado do exemplo: 116.15200161933899

Adicionar o |0 retira tudo depois do ponto decimal.
Ex: 116.15200161933899 -> 116

Usando .toString(16) converte este número em hexadecimal (base 16).
Ex: 116 -> 74
Outro ex: 228 - > E4

Adicionando "0" enche-o com um zero. Isto será importante quando tivermos a substring, já que nosso resultado final deve ter dois caracteres para cada cor.
Ex: 74 -> 074
Outro ex: 8 -> 08

.substr(-2) só tem as duas últimas personagens.
Ex: 074 -> 74
Outro ex: 08 - > 08 (se não tivéssemos adicionado o "0", este teria produzido " 8 "em vez de "08")

O ciclo for executa este ciclo três vezes, adicionando cada resultado à cadeia de cores, produzindo algo assim:
#7408e4

Se és um idiota como eu, sem noção sobre hexadecimais e tal, isto pode ser mais intuitivo.

function r() { return Math.floor(Math.random() * 255) }

var color = 'rgb(' + r() + "," + r() + "," + r() + ')';

Só precisas de acabar com uma corda como:'rgb(255, 123, 220)'

Então, embora todas as respostas aqui sejam boas, eu queria um pouco mais de controle sobre a saída. Por exemplo, eu gostaria de evitar quaisquer sombras quase brancas, ao mesmo tempo que garantir que eu tenho cores vibrantes brilhantes e não nubladas.

function generateColor(ranges) {
            if (!ranges) {
                ranges = [
                    [150,256],
                    [0, 190],
                    [0, 30]
                ];
            }
            var g = function() {
                //select random range and remove
                var range = ranges.splice(Math.floor(Math.random()*ranges.length), 1)[0];
                //pick a random number from within the range
                return Math.floor(Math.random() * (range[1] - range[0])) + range[0];
            }
            return "rgb(" + g() + "," + g() + "," + g() +")";
        };

Então agora posso especificar 3 intervalos arbitrários para escolher os valores rgb de. Você pode chamá-lo sem argumentos e obter o meu conjunto padrão que normalmente irá gerar uma cor bastante vibrante com uma sombra dominante óbvia, ou você pode fornecer sua própria variedade de intervalos.

Resposta Curta Com pad Para tamanho exacto

'#'+((1<<24)*(Math.random()+1)|0).toString(16).substr(1)

Mais um gerador de cores aleatórias:

var randomColor;
randomColor = Math.random() * 0x1000000; // 0 < randomColor < 0x1000000 (randomColor is a float)
randomColor = Math.floor(randomColor); // 0 < randomColor <= 0xFFFFFF (randomColor is an integer)
randomColor = randomColor.toString(16); // hex representation randomColor
randomColor = ("000000" + randomColor).slice(-6); // leading zeros added
randomColor = "#" + randomColor; // # added

Array.prototype.reduce torna-o muito limpo.

["r","g","b"].reduce(function(res) {
    return res + ("0"+~~(Math.random()*256).toString(16)).slice(-2)
}, "#")

---

Precisa de um shim para navegadores velhos.

Pode usar esta função simples

function getRandomColor(){
 var color =  "#" + (Math.random() * 0xFFFFFF << 0).toString(16);
 return color;
}

O comentário mais votado da melhor resposta sugere que a abordagem de Martin Ankerl é melhor do que números hex aleatórios, e apesar de não ter melhorado a metodologia de Ankerl, traduzi-a com sucesso para JavaScript. Eu pensei que eu iria postar uma resposta adicional para este já mega-size assim thread porque a resposta superior tem outro comentário ligando a um Gist com a implementação JS da lógica de Ankerl e que link é quebrado (404). Se eu tivesse a reputação, teria simplesmente comentou o link jsbin que eu criei.

// adapted from
// http://jsfiddle.net/Mottie/xcqpF/1/light/
const rgb2hex = (rgb) => {
 return (rgb && rgb.length === 3) ? "#" +
  ("0" + parseInt(rgb[0],10).toString(16)).slice(-2) +
  ("0" + parseInt(rgb[1],10).toString(16)).slice(-2) +
  ("0" + parseInt(rgb[2],10).toString(16)).slice(-2) : '';
}

// next two methods converted from Ruby to JS
// soured from http://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/

// # HSV values in [0..1[
// # returns [r, g, b] values from 0 to 255
const hsv_to_rgb = (h, s, v) => {
  const h_i = Math.floor(h*6)
  const f = h*6 - h_i
  const p = v * (1 - s)
  const q = v * (1 - (f * s))
  const t = v * (1 - (1 - f) * s)
  let r, g, b
  switch(h_i){
    case(0):
      [r, g, b] = [v, t, p]
      break
    case(1):
      [r, g, b] = [q, v, p]
      break
    case(2):
      [r, g, b] = [p, v, t]
      break
    case(3):
      [r, g, b] = [p, q, v]
      break
    case(4):
      [r, g, b] = [t, p, v]
      break
    case(5):
      [r, g, b] = [v, p, q]
      break
  }
  return [Math.floor(r * 256), Math.floor(g * 256), Math.floor(b * 256)]
}

// # use golden ratio
const golden_ratio_conjugate = 0.618033988749895
let h = Math.random() // # use random start value
const gen_hex = (numberOfColors) => {
  const colorArray = []
  while (numberOfColors > 0) {
    h += golden_ratio_conjugate
    h %= 1
    colorArray.push(rgb2hex(hsv_to_rgb(h, 0.99, 0.99)))
    numberOfColors -= 1
  }
  console.log(colorArray)
  return colorArray
}

gen_hex(100)

Https://jsbin.com/qeyevoj/edit?js, consola

Versão ES6.

Cor Aleatória

`#${Math.floor(Math.random() * 0x1000000).toString(16).padStart(6, 0)}`

Alfa Aleatório, cor aleatória.

`#${Math.floor(Math.random() * 0x100000000).toString(16).padStart(8, 0)}`

function get_random_color() {
    return "#" + (Math.round(Math.random() * 0XFFFFFF)).toString(16);
}

Http://jsfiddle.net/XmqDz/1/

Usar cores distintas .

Gera uma paleta de visualmente cores distintas.

As cores distintas são altamente configuráveis:

• Escolha quantas cores estão na paleta
• restringir a matiz a um intervalo específico
• restringir o croma (saturação) a uma gama específica
• restringir a leveza a uma gama específica
• Configure a qualidade geral da paleta

Aqui estão as minhas duas versões para um gerador de código hexadecimal Aleatório.

/* Slowest but shortest. */
"#000000".replace(/0/g,function(){return (~~(Math.random()*16)).toString(16);});    

/* Good performance with small size. */
"#"+(function(a,b){while(a--){b+=""+(~~(Math.random()*16)).toString(16);} return b;})(6,"");

/* Remy Sharp provided one that's the fastest but a little bit too long */
(function(h){return '#000000'.substr(0,7-h.length)+h})((~~(Math.random()*(1<<24))).toString(16))

Esta função vai acima e além de outras respostas de duas maneiras:

Ele tenta gerar cores tão distintas quanto possível, encontrando que cor em 20 tentativas tem a mais distante distância euclidiana de os outros no cone HSV Permite-lhe restringir a tonalidade, saturação, ou intervalo de valores, mas ainda tenta escolher as cores como o mais distinto possível dentro desse alcance. Não é super eficiente, mas para valores razoáveis. separar 100 cores facilmente? É rápido o suficiente.

Ver JSFiddle

  /**
   * Generates a random palette of HSV colors.  Attempts to pick colors
   * that are as distinct as possible within the desired HSV range.
   *
   * @param {number}    [options.numColors=10] - the number of colors to generate
   * @param {number[]}  [options.hRange=[0,1]] - the maximum range for generated hue
   * @param {number[]}  [options.sRange=[0,1]] - the maximum range for generated saturation
   * @param {number[]}  [options.vRange=[0,1]] - the maximum range for generated value
   * @param {number[][]}[options.exclude=[[0,0,0],[0,0,1]]] - colors to exclude
   * 
   * @returns {number[][]} an array of HSV colors (each HSV color 
   * is a [hue, saturation, value] array)
   */
  function randomHSVPalette(options) {
    function random(min, max) {
      return min + Math.random() * (max - min);
    } 

    function HSVtoXYZ(hsv) {
      var h = hsv[0];
      var s = hsv[1];
      var v = hsv[2];
      var angle = h * Math.PI * 2;
      return [Math.sin(angle) * s * v,
              Math.cos(angle) * s * v,
              v];
    }

    function distSq(a, b) {
      var dx = a[0] - b[0];
      var dy = a[1] - b[1];
      var dz = a[2] - b[2];
      return dx * dx + dy * dy + dz * dz;
    }

    if (!options) {
      options = {};
    }

    var numColors = options.numColors || 10;
    var hRange = options.hRange || [0, 1];
    var sRange = options.sRange || [0, 1];
    var vRange = options.vRange || [0, 1];
    var exclude = options.exclude || [[0, 0, 0], [0, 0, 1]];

    var points = exclude.map(HSVtoXYZ);
    var result = [];

    while (result.length < numColors) {
      var bestHSV;
      var bestXYZ;
      var bestDist = 0;
      for (var i = 0; i < 20; i++) {
        var hsv = [random(hRange[0], hRange[1]), random(sRange[0], sRange[1]), random(vRange[0], vRange[1])];
        var xyz = HSVtoXYZ(hsv);
        var minDist = 10;
        points.forEach(function(point) {
          minDist = Math.min(minDist, distSq(xyz, point));
        });
        if (minDist > bestDist) {
          bestHSV = hsv;
          bestXYZ = xyz;
          bestDist = minDist;
        }
      }
      points.push(bestXYZ);
      result.push(bestHSV);
    }

    return result;
  }

  function HSVtoRGB(hsv) {
    var h = hsv[0];
    var s = hsv[1];
    var v = hsv[2];

    var i = ~~(h * 6);
    var f = h * 6 - i;
    var p = v * (1 - s);
    var q = v * (1 - f * s);
    var t = v * (1 - (1 - f) * s);
    v = ~~(255 * v);
    p = ~~(255 * p);
    q = ~~(255 * q); 
    t = ~~(255 * t);
    switch (i % 6) {
      case 0: return [v, t, p];
      case 1: return [q, v, p];
      case 2: return [p, v, t];
      case 3: return [p, q, v];
      case 4: return [t, p, v];
      case 5: return [v, p, q];
    }
  }

  function RGBtoCSS(rgb) {
    var r = rgb[0];
    var g = rgb[1];
    var b = rgb[2];
    var rgb = (r << 16) + (g << 8) + b;
    return '#' + ('000000' + rgb.toString(16)).slice(-6);
  }

Quase todos os métodos de mão curta anteriores estão a gerar códigos hex inválidos (cinco dígitos). Deparei-me com uma técnica semelhante apenas sem esse problema aqui.:

"#"+("000"+(Math.random()*(1<<24)|0).toString(16)).substr(-6)

Teste

Tenta isto na consola:

for(i = 0; i < 200; i++) {
    console.log("#" + ("000" + (Math.random()*(1<<24)|0).toString(16)).substr(-6));
}

Há tantas maneiras de conseguir isto. Aqui estão dois que eu fiz:

Gera seis dígitos hexadecimais aleatórios (0-F)

function randColor() {
    for (var i=0, col=''; i<6; i++) {
        col += (Math.random()*16|0).toString(16);
    }
    return '#'+col;
}

Gera componentes RGB individuais (00-FF)

function randColor2() {
    var r = ('0'+(Math.random()*256|0).toString(16)).slice(-2),
        g = ('0'+(Math.random()*256|0).toString(16)).slice(-2),
        b = ('0'+(Math.random()*256|0).toString(16)).slice(-2);
    return '#' +r+g+b;
}

Pode usar colorchain.js para gerar uma sequência de cores com matizes variáveis.

Este método irá obter um número aleatório, convertê-lo em uma cadeia hexidecimal e, em seguida, extrair uma parte dele, dando-lhe um feitiço Aleatório.

function randomColor() {
    return "#" + Math.random().toString(16).slice(2,8);
}

A minha versão:

function RandomColor() {
  var hex = (Math.round(Math.random()*0xffffff)).toString(16);
  while (hex.length < 6) hex = "0" + hex;
  return hex;
}