Convalida l'URL di YouTube utilizzando Regex

Question

Sto provando a convalidare gli URL di YouTube per la mia applicazione.

Finora ho il seguente:

// Set the youtube URL 
$youtube_url = "www.youtube.com/watch?v=vpfzjcCzdtCk"; 

if (preg_match("/((http\:\/\/){0,}(www\.){0,}(youtube\.com){1} || (youtu\.be){1}(\/watch\?v\=[^\s]){1})/", $youtube_url) == 1) 
{ 
    echo "Valid"; 
else 
{ 
    echo "Invalid"; 
} 

desidero validare le seguenti variazioni di Youtube Urls:

• Con e senza http: //
• Con e senza www.
• Con gli URL youtube.com e youtu.be
• Deve avere/watch? V =
• Deve avere la stringa unico video (Nell'esempio precedente "vpfzjcCzdtCk")

Tuttavia, non credo di aver ottenuto il mio diritto di logica, perché per qualche motivo restituisce vero per: www.youtube.co/watch?v=vpfzjcCzdtCk (notare che ho scritto in modo errato con .co e non .com)

Answer 1

Ci sono un sacco di licenziamenti in questa regolare espressione del tuo (e anche, il leaning toothpick syndrome). Questo, però, dovrebbe produrre risultati:

$rx = '~ 
    ^(?:https?://)?       # Optional protocol 
    (?:www[.])?        # Optional sub-domain 
    (?:youtube[.]com/watch[?]v=|youtu[.]be/) # Mandatory domain name (w/ query string in .com) 
    ([^&]{11})        # Video id of 11 characters as capture group 1 
    ~x'; 

$has_match = preg_match($rx, $url, $matches); 

// if matching succeeded, $matches[1] would contain the video ID 

Alcune note:

• utilizzano il carattere tilde ~ come delimitatore, per evitare LTS
• uso [.] invece di \. per migliorare la leggibilità visiva ed evitare LTS . (Caratteri "speciali" - come il punto . - non hanno effetto nelle classi di caratteri (entro parentesi quadre))
• per rendere le espressioni regolari più "leggibili" è possibile utilizzare il modificatore x (che ha ulteriori implicazioni; vedere the docs on Pattern modifiers) , che consente anche commenti nelle espressioni regolari
• La cattura può essere soppressa utilizzando i gruppi non di acquisizione: (?: <pattern>). Questo rende l'espressione più efficiente.

---

Opzionalmente, per estrarre i valori da un URL (più o meno completa), si potrebbe desiderare di fare uso di parse_url():

$url = 'http://youtube.com/watch?v=VIDEOID'; 
$parts = parse_url($url); 
print_r($parts); 

uscita:

Array 
(
    [scheme] => http 
    [host] => youtube.com 
    [path] => /watch 
    [query] => v=VIDEOID 
) 

Convalida il nome di dominio e l'estrazione dell'ID video vengono lasciati come esercizio al lettore.

---

Mi sono arreso al commento guerra di seguito; grazie a Toni Oriol, l'espressione regolare ora funziona anche con URL brevi (youtu.be).

Answer 2

si prega di provare:

// Set the youtube URL 
$youtube_url = "www.youtube.com/watch?v=vpfzjcCzdtCk"; 

if (preg_match("/^((http\:\/\/){0,}(www\.){0,}(youtube\.com){1}|(youtu\.be){1}(\/watch\?v\=[^\s]){1})$/", $youtube_url) == 1) 
{ 
    echo "Valid"; 
} 
else 
{ 
    echo "Invalid"; 
} 

Si aveva || che va bene senza^$ in ogni caso.

Answer 3

Questo dovrebbe farlo:

$valid = preg_match("/^(https?\:\/\/)?(www\.)?(youtube\.com|youtu\.be)\/watch\?v\=\w+$/", $youtube_url); 
if ($valid) { 
    echo "Valid"; 
} else { 
    echo "Invalid"; 
} 

Answer 4

Un'alternativa alle espressioni regolari sarebbe parse_url().

$parts = parse_url($url); 
if ($parts['host'] == 'youtube.com' && ...) { 
    // your code 
} 

Mentre è più codice, è più leggibile e quindi più mantenibile.

Answer 5

Mi rimetto alle altre risposte in questa pagina per l'analisi del sintassi URL, ma per l'ID YouTube stessi valori, si può essere un po 'più specifico, come ho descritto nel seguente risposta su StackExchange/webapps:

Format for ID of YouTube video - https://webapps.stackexchange.com/a/101153/141734

---

Id Video

Per il videoId, è un numero intero a 8 byte (64 bit). L'applicazione della codifica Base64 a 8 byte di dati richiede 11 caratteri. Tuttavia, poiché ogni carattere Base64 trasmette esattamente 6 bit, questa allocazione potrebbe effettivamente contenere fino a 11 × 6 = 66 bit - un surplus di 2 bit rispetto a quello di cui il nostro carico utile ha bisogno. I bit in eccesso sono impostati su zero, il che ha l'effetto di escludere alcuni caratteri dall'apparire sempre nell'ultima posizione della stringa codificata. In particolare, il videoId sarà sempre termina con uno dei seguenti:

{ A, E, I, M, Q, U, Y, c, g, k, o, s, w, 0, 4, 8 } 

Pertanto, un'espressione regolare (RegEx) per il videoId sarebbe la seguente:

[-_A-Za-z0-9]{10}[AEIMQUYcgkosw048] 

Canale o ID playlist

Il canaleId e playlistId Le stringhe sono prodotte da Base64 che codifica un numero binario a 128 bit (16 byte). Anche in questo caso, il calcolo per Base64 prevede correttamente la lunghezza della stringa osservata di 22 caratteri. In questo caso, l'output è in grado di codificare 22 × 6 = 132 bit, un surplus di 4 bit; quegli zeri finiscono per limitare la maggior parte dei 64 simboli alfabetici dall'ultima posizione, e solo 4 rimangono idonei. Tutti channelId stringhe terminano in uno dei seguenti modi:

{ A, Q, g, w } 

Questo ci dà l'espressione regolare per un channelId:

[-_A-Za-z0-9]{21}[AQgw]