let r = Math.random().toString(36).substring(7);
console.log("random", r);

Matematyka.random jest złe dla tego typu rzeczy

Opcja 1

Jeśli jesteś w stanie to zrobić Serwer -strona, wystarczy użyć crypto moduł

var crypto = require("crypto");
var id = crypto.randomBytes(20).toString('hex');

// "bb5dc8842ca31d4603d6aa11448d1654"

Wynikowy ciąg znaków będzie dwa razy dłuższy od generowanych losowych bajtów; każdy bajt zakodowany do szesnastki to 2 znaki. 20 bajtów to 40 znaków szesnastkowych.

Opcja 2

Jeśli musisz to zrobić client - strona, może spróbuj uuid Moduł

var uuid = require("uuid");
var id = uuid.v4();

// "110ec58a-a0f2-4ac4-8393-c866d813b8d1"

Opcja 3

Jeśli musisz to zrobić client - side i nie musisz obsługiwać starych przeglądarek, możesz to zrobić bez zależności

// dec2hex :: Integer -> String
function dec2hex (dec) {
  return ('0' + dec.toString(16)).substr(-2)
}

// generateId :: Integer -> String
function generateId (len) {
  var arr = new Uint8Array((len || 40) / 2)
  window.crypto.getRandomValues(arr)
  return Array.from(arr, dec2hex).join('')
}

console.log(generateId())
// "82defcf324571e70b0521d79cce2bf3fffccd69"

console.log(generateId(20))
// "c1a050a4cd1556948d41"

Oto poprawa doskonała odpowiedź doubletap . Oryginał ma dwie wady, które są tutaj omówione:

Po pierwsze, jak wspomnieli inni, ma małe prawdopodobieństwo wytworzenia krótkich ciągów lub nawet pustego ciągu (jeśli liczba losowa wynosi 0), co może złamać Twoją aplikację. Oto rozwiązanie:

(Math.random().toString(36)+'00000000000000000').slice(2, N+2)

Po drugie, zarówno oryginał, jak i powyższe rozwiązanie ograniczają rozmiar łańcucha n do 16 znaków. Poniższe zwróci ciąg o rozmiarze N dla dowolnego N (ale zauważ, że użycie N > 16 nie zwiększy losowości ani nie zmniejszy prawdopodobieństwa kolizji):

Array(N+1).join((Math.random().toString(36)+'00000000000000000').slice(2, 18)).slice(0, N)

Wyjaśnienie:

1. Wybierz liczbę losową z zakresu [0,1), tzn. z zakresu od 0 (włącznie) do 1 (wyłącznie).
2. Przelicz liczbę na łańcuch bazy-36, tzn. używając znaków 0-9 i a-z.
3. Pad z zerami (rozwiązuje pierwszy problem).
4. odetnij czołówkę "0"."prefiks i dodatkowe zera dopełniające.
5. powtórz ciąg wystarczająco dużo razy, aby zawiera co najmniej N znaków (łącząc puste ciągi z krótszym losowym ciągiem używanym jako ogranicznik).
6. wycinamy dokładnie N znaków z łańcucha.

Dalsze myśli:

• w tym rozwiązaniu nie używa się wielkich liter, ale w prawie wszystkich przypadkach (nie zamierzony kalambur) nie ma to znaczenia.
• maksymalna długość łańcucha przy N = 16 w oryginalnej odpowiedzi jest mierzona w chromie. W Firefoksie jest N = 11. Ale jak wyjaśniono, drugie rozwiązanie jest o obsługa dowolnej żądanej długości łańcucha, a nie dodawanie losowości, więc nie robi to wielkiej różnicy.
• wszystkie zwracane ciągi mają równe prawdopodobieństwo, że zostaną zwrócone, przynajmniej tak dalece, jak wyniki zwracane przez matematykę.random() są równomiernie rozłożone (w żadnym wypadku nie jest to losowość siły kryptograficznej).
• nie wszystkie możliwe łańcuchy o rozmiarze N mogą zostać zwrócone. W drugim rozwiązaniu jest to oczywiste (ponieważ mniejszy ciąg jest po prostu powielany), ale także w oryginalnej odpowiedzi jest to prawdą, ponieważ w konwersji do bazy-36 kilka ostatnich bitów może nie być częścią oryginalnych bitów losowych. Konkretnie, jeśli spojrzeć na wynik matematyki.random().toString (36), zauważysz, że ostatni znak nie jest równomiernie rozłożony. Ponownie, w prawie wszystkich przypadkach nie ma to znaczenia, ale odcinamy ostatni ciąg od początku, a nie od końca losowego łańcucha, tak aby krótkie ciągi (np. N = 1) nie były dotknięte.

Update:

Oto kilka innych funkcjonalnych jednolinijek, które wymyśliłem. Różnią się one od powyższego rozwiązania tym, że:

• używają jawnego arbitralnego alfabetu(bardziej ogólnego i odpowiedniego do oryginalnego pytania, które wymagało zarówno wielkich, jak i małych liter).
• wszystkie ciągi o długości N mają równe prawdopodobieństwo powrotu (tzn. ciągi nie zawierają powtórzeń).
• są oparte na mapie funkcji, a nie sztuczki toString (36), co czyni je prostszymi i łatwiejszymi do zrozumienia.

Więc powiedz, że Twój alfabet jest

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Wtedy te dwa są sobie równoważne, więc możesz wybrać to, co jest bardziej intuicyjne dla ciebie:

Array(N).join().split(',').map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

I

Array.apply(null, Array(N)).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

Edit:

Wydaje mi się, żequbyte i Martijn de Milliano wymyślił rozwiązania podobne do tych ostatnich (kudos!), które jakoś przeoczyłem. Od nie wyglądają tak krótko na pierwszy rzut oka, i tak zostawię to tutaj na wypadek, gdyby ktoś naprawdę chciał jednoliterowy: -)

We wszystkich rozwiązaniach zastąpiono 'new Array' przez 'Array', aby zmniejszyć liczbę bajtów.

Krótki, łatwy i niezawodny

Zwraca dokładnie 5 losowych znaków, w przeciwieństwie do niektórych z najlepiej ocenianych odpowiedzi znalezionych tutaj.

Math.random().toString(36).substr(2, 5);

Coś takiego powinno działać

function randomString(len, charSet) {
    charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    var randomString = '';
    for (var i = 0; i < len; i++) {
        var randomPoz = Math.floor(Math.random() * charSet.length);
        randomString += charSet.substring(randomPoz,randomPoz+1);
    }
    return randomString;
}

Wywołaj z domyślnym zestawem znaków [a-zA-Z0-9] lub wyślij własne:

var randomValue = randomString(5);

var randomValue = randomString(5, 'PICKCHARSFROMTHISSET');

function randomstring(L) {
  var s = '';
  var randomchar = function() {
    var n = Math.floor(Math.random() * 62);
    if (n < 10) return n; //1-10
    if (n < 36) return String.fromCharCode(n + 55); //A-Z
    return String.fromCharCode(n + 61); //a-z
  }
  while (s.length < L) s += randomchar();
  return s;
}
console.log(randomstring(5));

Najbardziej kompaktowe rozwiązanie, ponieważ slice jest krótszy niż substring. Odejmowanie od końca łańcucha pozwala uniknąć symbolu zmiennoprzecinkowego generowanego przez random funkcja:

Math.random().toString(36).slice(-5);

Lub nawet

(+new Date).toString(36).slice(-5);

// Using Math.random
console.log(Math.random().toString(36).slice(-5));

// Using new Date
console.log((+new Date).toString(36).slice(-5));

Random String Generator (Alpha-Numeric | Alpha | Numeric)

/**
 * RANDOM STRING GENERATOR
 *
 * Info:      http://stackoverflow.com/a/27872144/383904
 * Use:       randomString(length [,"A"] [,"N"] );
 * Default:   return a random alpha-numeric string
 * Arguments: If you use the optional "A", "N" flags:
 *            "A" (Alpha flag)   return random a-Z string
 *            "N" (Numeric flag) return random 0-9 string
 */
function randomString(len, an){
    an = an&&an.toLowerCase();
    var str="", i=0, min=an=="a"?10:0, max=an=="n"?10:62;
    for(;i++<len;){
      var r = Math.random()*(max-min)+min <<0;
      str += String.fromCharCode(r+=r>9?r<36?55:61:48);
    }
    return str;
}

randomString(10);        // "4Z8iNQag9v"
randomString(10, "A");   // "aUkZuHNcWw"
randomString(10, "N");   // "9055739230"

Podczas gdy powyższe używa dodatkowych kontroli dla żądanego (A / N, A, N) wyjścia, Podzielmy to na podstawowe (tylko alfanumeryczne) dla lepszego zrozumienia:

• Utwórz funkcję, która przyjmuje argument (żądaną długość losowego wyniku łańcucha)
• Utwórz pusty ciąg znaków podobnie jak var str = ""; aby połączyć losowe znaki
• wewnątrz pętli Utwórz rand Numer indeksu od 0 do 61 (0..9 + A..Z + a..z = 62)
• Utwórz logikę warunkową aby dopasować / naprawić rand (skoro jest 0..61) zwiększenie go o pewną liczbę (patrz przykłady poniżej), aby uzyskać z powrotem właściwą liczbę CharCode i powiązany znak.
• wewnątrz pętli konkatenat do str a String.fromCharCode( incremented rand )

Wyobraźmy sobie tabelę znaków i ich zakresy :

_____0....9______A..........Z______a..........z___________  Character
     | 10 |      |    26    |      |    26    |             Tot = 62 characters
    48....57    65..........90    97..........122           CharCode ranges

Math.floor( Math.random * 62 ) daje zakres od 0..61 (czego potrzebujemy). Jak naprawić (przyrost) losowe, aby uzyskać poprawne zakresy charCode?

      |   rand   | charCode |  (0..61)rand += fix            = charCode ranges |
------+----------+----------+--------------------------------+-----------------+
0..9  |   0..9   |  48..57  |  rand += 48                    =     48..57      |
A..Z  |  10..35  |  65..90  |  rand += 55 /*  90-35 = 55 */  =     65..90      |
a..z  |  36..61  |  97..122 |  rand += 61 /* 122-61 = 61 */  =     97..122     |

Operacja warunkowa logika z powyższej tabeli:

   rand += rand>9 ? ( rand<36 ? 55 : 61 ) : 48 ;
// rand +=  true  ? (  true   ? 55 else 61 ) else 48 ;

Jeśli zastosowałeś się do powyższego wyjaśnienia, powinieneś być w stanie utworzyć ten fragment alfanumeryczny:

jsBin demo

function randomString( len ) {
  var str = "";                                         // String result
  for(var i=0; i<len; i++){                             // Loop `len` times
    var rand = Math.floor( Math.random() * 62 );        // random: 0..61
    var charCode = rand+= rand>9? (rand<36?55:61) : 48; // Get correct charCode
    str += String.fromCharCode( charCode );             // add Character to str
  }
  return str;       // After all loops are done, return the concatenated string
}

console.log( randomString(10) ); // "7GL9F0ne6t"

lub jeśli będziesz:

function randomString( n ) {
  var r="";
  while(n--)r+=String.fromCharCode((r=Math.random()*62|0,r+=r>9?(r<36?55:61):48));
  return r;
}

Najprostszy sposób to:

(new Date%9e6).toString(36)

Generuje losowe ciągi znaków 5 na podstawie bieżącego czasu. Przykładowe wyjście to 4mtxj lub 4mv90 lub 4mwp1

Problem polega na tym, że jeśli wywołasz go dwa razy w tej samej sekundzie, wygeneruje ten sam ciąg znaków.

Bezpieczniejszym sposobem jest:

(0|Math.random()*9e6).toString(36)

Spowoduje to wygenerowanie losowego ciągu 4 lub 5 znaków, zawsze różniących się od siebie. Przykładowe wyjście to 30jzm lub 1r591 lub 4su1a

W obie strony pierwsza część Wygeneruj losową liczbę. Część .toString(36) oddała numer do reprezentacji base36 (alfadecymalnej).

Nowsza wersja z es6 Operator spreadu :

[...Array(30)].map(() => Math.random().toString(36)[3]).join('')

• 30 jest dowolną liczbą, możesz wybrać dowolną długość tokena
• 36 jest maksymalną liczbą radix, którą można przekazać .toString () , co oznacza wszystkie Liczby i małe litery a-z
• 3 służy do wybrania trzeciej liczby z losowego ciągu, który wygląda tak: "0.mfbiohx64i", możemy wziąć dowolny indeks po 0.

Oto kilka prostych linerów. Zmień new Array(5), aby ustawić długość.

W tym 0-9a-z

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36);})

W tym 0-9a-zA-Z

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36)[Math.random()<.5?"toString":"toUpperCase"]();});

Jeśli używasz Lodash lub Underscore , to jest to takie proste:

var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join('');

Wiem, że każdy ma już rację, ale miałem ochotę spróbować tego w jak najlżejszy sposób (światło na kod, nie na procesor):

function rand(length, current) {
  current = current ? current : '';
  return length ? rand(--length, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz".charAt(Math.floor(Math.random() * 60)) + current) : current;
}

console.log(rand(5));

To zajmuje trochę czasu, aby owinąć głowę wokół, ale myślę, że to naprawdę pokazuje, jak niesamowite składnia javascript jest.

Zakładając, że używasz podkreślników możliwe jest eleganckie wygenerowanie losowego ciągu w zaledwie dwóch liniach:

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var random = _.sample(possible, 5).join('');

Oto metoda, którą stworzyłem.
Utworzy łańcuch zawierający zarówno wielkie, jak i małe znaki.
Dodatkowo dodałem funkcję, która utworzy również ciąg alfanumeryczny.

Przykłady pracy:
http://jsfiddle.net/greatbigmassive/vhsxs / (tylko alfa)
http://jsfiddle.net/greatbigmassive/PJwg8 / (alfanumeryczny)

function randString(x){
    var s = "";
    while(s.length<x&&x>0){
        var r = Math.random();
        s+= String.fromCharCode(Math.floor(r*26) + (r>0.5?97:65));
    }
    return s;
}

Upgrade Lipiec 2015
Robi to samo, ale ma większy sens i zawiera wszystkie litery.

var s = "";
while(s.length<x&&x>0){
    v = Math.random()<0.5?32:0;
    s += String.fromCharCode(Math.round(Math.random()*((122-v)-(97-v))+(97-v)));
}

W przypadku, gdyby ktoś był zainteresowany jednowierszowym (choć nie sformatowanym jako taki dla Twojej wygody), który przydziela pamięć na raz (ale zauważ, że dla małych łańcuchów naprawdę nie ma to znaczenia) oto jak to zrobić: {]}

Array.apply(0, Array(5)).map(function() {
    return (function(charset){
        return charset.charAt(Math.floor(Math.random() * charset.length))
    }('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'));
}).join('')

Możesz zastąpić 5 przez żądaną długość łańcucha. Dzięki @AriyaHidayat w Ten post za rozwiązanie {[2] } funkcji nie działającej na tablicy sparse utworzonej przez Array(5).

Aby spełnić wymagania [a-zA-Z0 - 9] i długość = 5 Użyj

btoa(Math.random()).substr(5, 5);

Pojawią się małe litery, wielkie litery i cyfry.

Szybki i ulepszony algorytm. Nie gwarantuje jednolitego (patrz komentarze).

function getRandomId(length) {
    if (!length) {
        return '';
    }

    const possible =
        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    let array;

    if ('Uint8Array' in self && 'crypto' in self && length <= 65536) {
        array = new Uint8Array(length);
        self.crypto.getRandomValues(array);
    } else {
        array = new Array(length);

        for (let i = 0; i < length; i++) {
            array[i] = Math.floor(Math.random() * 62);
        }
    }

    for (let i = 0; i < length; i++) {
        result += possible.charAt(array[i] % 62);
    }

    return result;
}

function randomString (strLength, charSet) {
    var result = [];

    strLength = strLength || 5;
    charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

    while (--strLength) {
        result.push(charSet.charAt(Math.floor(Math.random() * charSet.length)));
    }

    return result.join('');
}

Możesz przechodzić przez tablicę elementów i rekurencyjnie dodawać je do zmiennej łańcuchowej, na przykład, jeśli chcesz losowej sekwencji DNA:

function randomDNA(len) {
  len = len || 100
  var nuc = new Array("A", "T", "C", "G")
  var i = 0
  var n = 0
  s = ''
  while (i <= len - 1) {
    n = Math.floor(Math.random() * 4)
    s += nuc[n]
    i++
  }
  return s
}

console.log(randomDNA(5));

Nie znalazłem czystego rozwiązania dla obsługi zarówno małych, jak i wielkich znaków.

Obsługa tylko małych liter:

Math.random().toString(36).substr(2, 5)

Opierając się na tym rozwiązaniu, aby obsługiwać małe i wielkie litery:

Math.random().toString(36).substr(2, 5).split('').map(c => Math.random() < 0.5 ? c.toUpperCase() : c).join('');

Zmień 5 w substr(2, 5), aby dostosować się do potrzebnej długości.

A może coś takiego: Date.now().toString(36) Niezbyt przypadkowy, ale krótki i dość wyjątkowy za każdym razem, gdy go nazywasz.

To działa na pewno

<script language="javascript" type="text/javascript">
function randomString() {
 var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
 var string_length = 8;
 var randomstring = '';
 for (var i=0; i<string_length; i++) {
  var rnum = Math.floor(Math.random() * chars.length);
  randomstring += chars.substring(rnum,rnum+1);
 }
 document.randform.randomfield.value = randomstring;
}
</script>

Wygeneruj ciąg znaków o długości 10 znaków. Długość jest ustawiana przez parametr (domyślnie 10).

function random_string_generator(len) {
var len = len || 10;
var str = '';
var i = 0;

for(i=0; i<len; i++) {
    switch(Math.floor(Math.random()*3+1)) {
        case 1: // digit
            str += (Math.floor(Math.random()*9)).toString();
        break;

        case 2: // small letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 97); //'a'.charCodeAt(0));
        break;

        case 3: // big letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 65); //'A'.charCodeAt(0));
        break;

        default:
        break;
    }
}
return str;
}

Oto skrypt testowy dla odpowiedzi #1 (dziękuję @csharptest.net)

Skrypt działa makeid() 1 million razy i jak widać 5 nie jest bardzo wyjątkowy. uruchamianie go o długości znaku 10 jest dość niezawodne. Sprawdzałem to z 50 razy i nie widziałem jeszcze duplikatu :-)

Uwaga: limit rozmiaru stosu węzłów przekracza około 4 milionów, więc nie możesz uruchomić tego 5 milionów razy, nigdy nie skończy.

function makeid()
{
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    for( var i=0; i < 5; i++ )
        text += possible.charAt(Math.floor(Math.random() * possible.length));

    return text;
}

ids ={}
count = 0
for (var i = 0; i < 1000000; i++) {
    tempId = makeid();
    if (typeof ids[tempId] !== 'undefined') {
        ids[tempId]++;
        if (ids[tempId] === 2) {
            count ++;
        }
        count++;
    }else{
        ids[tempId] = 1;
    }
}
console.log("there are "+count+ ' duplicate ids');

Możesz użyć coderain . Jest to biblioteka do generowania losowych kodów zgodnie z podanym wzorem. Użyj # jako symbolu zastępczego dla wielkich i małych znaków oraz cyfr:

var cr = new CodeRain("#####");
console.log(cr.next());

Istnieją inne symbole zastępcze, takie jak A dla wielkich liter lub 9 dla cyfr.

Przydatne może być to, że wywołanie .next() zawsze daje unikalny wynik, więc nie musisz się martwić o duplikaty.

Oto aplikacja demonstracyjna, która generuje listę unikalnych losowe kody .

Pełna wersja: jestem autorem coderain.

Co powiesz na tę małą sztuczkę?

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var stringLength = 5;

function pickRandom() {
    return possible[Math.floor(Math.random() * possible.length)];
}

var randomString = Array.apply(null, Array(stringLength)).map(pickRandom).join('');

Potrzebujesz Array.apply tam, aby oszukać pustą tablicę w tablicę Undefined.

Jeśli kodujesz dla ES2015, zbudowanie tablicy jest nieco prostsze:

var randomString = Array.from({ length: stringLength }, pickRandom).join('');

Problem z odpowiedziami na "potrzebuję losowych ciągów" pytania (w dowolnym języku) jest praktycznie każde rozwiązanie używa wadliwej podstawowej specyfikacji długości ciągu . Same pytania rzadko ujawniają, dlaczego losowe ciągi są potrzebne, ale ja bym wyzwał, że rzadko potrzebujesz losowych ciągów o długości, powiedzmy 8. Niezmiennie potrzebujesz pewnej liczby unikalnych łańcuchów, na przykład, aby użyć ich jako identyfikatorów w jakimś celu.

Istnieją dwa wiodące sposoby uzyskania ściśle unikalnych ciągów: deterministycznie (co nie jest przypadkowe) i store/compare (co jest uciążliwe). Co robimy? Porzucimy ducha. Zamiast tego stosujemy wyjątkowość probabilistyczną . Oznacza to, że akceptujemy, że istnieje pewne (choć małe) ryzyko, że nasze struny nie będą wyjątkowe. Tutaj zrozumienie prawdopodobieństwo kolizji oraz Entropia są pomocne.

I tutaj może pomóc Biblioteka taka jak EntropyString . Aby wygenerować losowe identyfikatory, które mają mniej niż 1 na bilion szans na powtórzenie w 5 milionach ciągów za pomocą entropy-string:

import {Random, Entropy} from 'entropy-string'

const random = new Random()
const bits = Entropy.bits(5e6, 1e12)

const string = random.string(bits)

"44htnghjnhggrhqh9"

entropy-string domyślnie używa zestawu znaków składającego się z 32 znaków. Tam są innymi predefiniowanymi zestawami znaków, można również określić własne znaki. Na przykład generowanie identyfikatorów z taką samą entropią jak powyżej, ale za pomocą znaków szesnastkowych:

import {Random, Entropy, charSet16} from './entropy-string'

const random = new Random(charSet16)
const bits = Entropy.bits(5e6, 1e12)

const string = random.string(bits)

"27b33372ade513715481f"

Zwróć uwagę na różnicę w długości łańcucha ze względu na różnicę w całkowitej liczbie znaków w używanym zestawie znaków. Ryzyko powtórzenia w określonej liczbie potencjalnych ciągów jest takie samo. Długość sznurka nie jest. A co najlepsze, ryzyko repeat and the potential number of strings is explicit. Koniec z zgadywaniem z długością Sznurka.

Rozszerzenie na elegancki przykład Doubletap poprzez odpowiedź na problemy gertasa i Smoka podniesione. Po prostu dodaj pętlę while, aby przetestować te rzadkie okoliczności null i ogranicz znaki do pięciu.

function rndStr() {
    x=Math.random().toString(36).substring(7).substr(0,5);
    while (x.length!=5){
        x=Math.random().toString(36).substring(7).substr(0,5);
    }
    return x;
}

Oto jsfiddle ostrzega Cię o wyniku: http://jsfiddle.net/pLJJ7/