URL che codifica il carattere spazio: + o% 20?

Quando viene codificato uno spazio in un URL +e quando viene codificato %20?

Da Wikipedia (enfasi e collegamento aggiunti):

Quando vengono inviati dati immessi in moduli HTML, i nomi e i valori dei campi modulo vengono codificati e inviati al server in un messaggio di richiesta HTTP utilizzando il metodo GET o POST o, storicamente, via e-mail. La codifica utilizzata per impostazione predefinita si basa su una versione molto antica delle regole generali di codifica percentuale URI, con una serie di modifiche come la normalizzazione della nuova riga e la sostituzione di spazi con "+" anziché "% 20". Il tipo di dati MIME codificato in questo modo è application / x-www-form-urlencoded ed è attualmente definito (ancora in modo molto obsoleto) nelle specifiche HTML e XForms.

Pertanto, la codifica percentuale reale utilizza %20mentre i dati del modulo negli URL sono in una forma modificata che utilizza +. Quindi molto probabilmente vedrai +negli URL nella stringa di query solo dopo ?.

Questa confusione è perché gli URL sono ancora 'rotti' fino ad oggi.

Prendi " http://www.google.com " per esempio. Questo è un URL Un URL è un localizzatore di risorse uniforme ed è in realtà un puntatore a una pagina Web (nella maggior parte dei casi). Gli URL hanno in realtà una struttura molto ben definita dalla prima specifica nel 1994.

Possiamo estrarre informazioni dettagliate sull'URL " http://www.google.com ":

+---------------+-------------------+
|      Part     |      Data         |
+---------------+-------------------+
|  Scheme       | http              |
|  Host         | www.google.com    |
+---------------+-------------------+

Se osserviamo un URL più complesso come:

" https: // bob: bobby@www.lunatech.com: 8080 / file; p = 1? q = 2 # third "

possiamo estrarre le seguenti informazioni:

+-------------------+---------------------+
|        Part       |       Data          |
+-------------------+---------------------+
|  Scheme           | https               |
|  User             | bob                 |
|  Password         | bobby               |
|  Host             | www.lunatech.com    |
|  Port             | 8080                |
|  Path             | /file;p=1           |
|  Path parameter   | p=1                 |
|  Query            | q=2                 |
|  Fragment         | third               |
+-------------------+---------------------+

https://bob:bobby@www.lunatech.com:8080/file;p=1?q=2#third
\___/   \_/ \___/ \______________/ \__/\_______/ \_/ \___/
  |      |    |          |          |      | \_/  |    |
Scheme User Password    Host       Port  Path |   | Fragment
        \_____________________________/       | Query
                       |               Path parameter
                   Authority

I caratteri riservati sono diversi per ogni parte.

Per gli URL HTTP, uno spazio in una parte del frammento del percorso deve essere codificato in "% 20" (non, assolutamente non "+"), mentre il carattere "+" nella parte del frammento del percorso può essere lasciato non codificato.

Ora nella parte della query, gli spazi possono essere codificati in "+" (per compatibilità con le versioni precedenti: non tentare di cercarlo nello standard URI) o "% 20" mentre il carattere "+" (come risultato di questa ambiguità ) deve essere convertito in "% 2B".

Ciò significa che la stringa "blu + azzurro" deve essere codificata in modo diverso nelle parti del percorso e della query:

" http://example.com/blue+light%20blue?blue%2Blight+blue ".

Da lì puoi dedurre che la codifica di un URL completamente costruito è impossibile senza una consapevolezza sintattica della struttura dell'URL.

Questo si riduce a:

Dovresti avere %20prima ?e +dopo.

fonte

Lo consiglierei %20.

Li stai codificando?

Tuttavia, ciò non è molto coerente tra le lingue. Se non sbaglio, in PHP urlencode()tratta gli spazi come +mentre Python urlencode()li tratta come %20.

MODIFICARE:

Sembra che mi sbagli. Python's urlencode()(almeno in 2.7.2) utilizza quote_plus()invece di quote()e quindi codifica gli spazi come "+". Sembra anche che la raccomandazione del W3C sia il "+" come qui: http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1

E in effetti, puoi seguire questo interessante dibattito sul tracker dei problemi di Python su cosa usare per codificare gli spazi: http://bugs.python.org/issue13866 .

EDIT # 2:

Capisco che il modo più comune di codificare "" è come "+", ma solo una nota, potrei essere solo io, ma lo trovo un po 'confuso:

import urllib
print(urllib.urlencode({' ' : '+ '})

>>> '+=%2B+'

Uno spazio può essere codificato solo su "+" nelle coppie chiave-valore del tipo di contenuto "application / x-www-form-urlencoded" che interrogano parte di un URL. Secondo me, questo è un MAGGIO, non un DEVE. Nel resto degli URL, è codificato come% 20.

A mio avviso, è meglio codificare sempre gli spazi come% 20, non come "+", anche nella parte della query di un URL, poiché è la specifica HTML (RFC-1866) che ha specificato che i caratteri dello spazio devono essere codificati come " + "in" coppie chiave-valore del tipo di contenuto "application / x-www-form-urlencoded" (vedere paragrafo 8.2.1. comma 1.)

Questo modo di codificare i dati dei moduli è indicato anche nelle specifiche HTML successive. Ad esempio, cerca i paragrafi pertinenti su application / x-www-form-urlencoded in HTML 4.01 Specification e così via.

Ecco una stringa di esempio nell'URL in cui la specifica HTML consente di codificare gli spazi come vantaggi: " http://esempio.com/over/there?name=foo+bar ". Quindi, solo dopo "?", Gli spazi possono essere sostituiti da vantaggi . In altri casi, gli spazi devono essere codificati in% 20. Tuttavia, poiché è difficile determinare correttamente il contesto, è consigliabile non codificare mai gli spazi come "+".

Consiglierei di codificare in percentuale tutti i caratteri tranne "senza prenotazione" definito in RFC-3986, p. 2.3

unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"

L'implementazione dipende dal linguaggio di programmazione che hai scelto.

Se il tuo URL contiene caratteri nazionali, prima codificali in UTF-8, quindi codifica in percentuale il risultato.