Devo creare un sito Web che contenga articoli e vorrei creare URL amichevoli per esso, ad esempio l'URL della pagina con

Titolo: Articolo Test

dovrebbe diventare: http://www.example.com/articles/article_test.

Ovviamente devo rimuovere alcuni personaggi dal titolo come ?o #, ma non sono sicuro di quali rimuovere.

Qualcuno può dirmi quali personaggi sono sicuri da conservare?

Per citare la sezione 2.3 di RFC 3986 :

"I caratteri consentiti in un URI ma che non hanno uno scopo riservato sono chiamati senza prenotazione. Questi includono lettere maiuscole e minuscole, cifre decimali, trattino, punto, trattino basso e tilde."

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

Si noti che RFC 3986 elenca meno segni di punteggiatura riservati rispetto al precedente RFC 2396 .

Ci sono due serie di personaggi a cui devi fare attenzione: riservati e non sicuri .

I caratteri riservati sono:

• e commerciale ("&")
• dollaro ("$")
• segno più ("+")
• virgola (",")
• barra ("/")
• due punti (":")
• punto e virgola (";")
• equals ("=")
• punto interrogativo ("?")
• Simbolo "At" ("@")
• libbra ("#").

I personaggi generalmente considerati non sicuri sono:

• spazio (" ")
• minore di e maggiore di ("<>")
• parentesi aperte e chiuse ("[]")
• apri e chiudi parentesi graffe ("{}")
• pipe ("|")
• barra rovesciata ("\")
• caret ("^")
• per cento ("%")

Forse ne ho dimenticato uno o più, il che mi porta a fare eco alla risposta di Carl V. A lungo termine probabilmente stai meglio usando una "lista bianca" di caratteri consentiti e quindi codificando la stringa anziché cercare di stare al passo con i caratteri non consentiti da server e sistemi.

È meglio conservare solo alcuni caratteri (lista bianca) invece di rimuovere determinati caratteri (lista nera).

Puoi tecnicamente consentire qualsiasi personaggio, purché lo codifichi correttamente. Ma, per rispondere nello spirito della domanda, dovresti consentire solo a questi personaggi:

1. Lettere minuscole (converti maiuscole in minuscole)
2. Numeri, da 0 a 9
3. Un trattino - o trattino basso _
4. Tilde ~

Tutto il resto ha un significato potenzialmente speciale. Ad esempio, potresti pensare di poter usare +, ma può essere sostituito con uno spazio. ed è anche pericoloso, specialmente se si usano alcune regole di riscrittura.

Come per gli altri commenti, controlla gli standard e le specifiche per i dettagli completi.

Sempre al sicuro

Questi sono sicuri (in teoria / specifiche), praticamente ovunque tranne il nome del dominio.
Codifica in percentuale tutto ciò che non è elencato e sei a posto.

    A-Z a-z 0-9 - . _ ~ ( ) ' ! * : @ , ;

A volte sicuro

Sicuro solo se utilizzato all'interno di componenti URL specifici; usare con cura.

    Paths:     + & =
    Queries:   ? /
    Fragments: ? / # + & =
    

Mai al sicuro

Secondo le specifiche URI (RFC 3986), tutti gli altri caratteri devono essere codificati in percentuale. Ciò comprende:

    <space> <control-characters> <extended-ascii> <unicode>
    % < > [ ] { } | \ ^
    

Se la massima compatibilità è un problema, limitare il set di caratteri a AZ az 0-9 - _.
(con punti solo per le estensioni dei nomi).

Tieni presente il contesto

Anche se valido per specifica, un URL può essere comunque "non sicuro", a seconda del contesto. Ad esempio un file: /// URL contenente caratteri di nome file non validi o un componente di query contenente "?", "=" E "&" quando non utilizzato come delimitatori. La corretta gestione di questi casi dipende generalmente dai tuoi script e può essere risolta, ma è qualcosa da tenere a mente.

Guardando RFC3986 - Uniform Resource Identifier (URI): sintassi generica , la tua domanda ruota attorno al componente del percorso di un URI.

    foo://example.com:8042/over/there?name=ferret#nose
     \_/   \______________/\_________/ \_________/ \__/
      |           |            |            |        |
   scheme     authority       path        query   fragment
      |   _____________________|__
     / \ /                        \
     urn:example:animal:ferret:nose

Citando la sezione 3.3, i caratteri validi per un URI segmentsono di tipo pchar:

pchar = non prenotato / codificato PCT / sub-delim / ":" / "@"

Che si suddivide in:

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

pct-encoded

"!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="

":" / "@"

O in altre parole: è possibile utilizzare qualsiasi carattere (non-Controller) dalla tabella ASCII , tranne / , ?, #, [e ].

Questa comprensione è supportata da RFC1738 - Uniform Resource Locator (URL) .

senza prenotazione = ALPHA / DIGIT / "-" / "." / "_" / "~"

Dal contesto che descrivi, sospetto che ciò che stai effettivamente cercando di creare sia qualcosa chiamato "lumaca SEO". La migliore pratica generale conosciuta per quelli è:

1. Converti in minuscolo
2. Converti intere sequenze di caratteri diversi da az e 0-9 in un trattino (-) (non caratteri di sottolineatura)
3. Rimuovi "stop words" dall'URL, ovvero parole non indicizzabili come "a", "an" e "the"; Google "stop words" per elenchi completi

Quindi, ad esempio, un articolo intitolato "L'utilizzo di! @% $ * Per rappresentare il giuramento nei fumetti" otterrebbe una lumaca di "utilizzo-rappresentano-giuramento-fumetti".

Il formato per un URI è definito in RFC 3986 . Vedere la sezione 3.3 per i dettagli.

Dal punto di vista SEO, i trattini sono preferiti ai caratteri di sottolineatura. Converti in minuscolo, rimuovi tutti gli apostrofi, quindi sostituisci tutte le stringhe di caratteri non alfanumerici con un singolo trattino. Taglia i trattini in eccesso all'inizio e alla fine.

Ho avuto un problema simile, volevo avere abbastanza URL e sono arrivato alla conclusione che devo consentire solo lettere, cifre, e _ negli URL. Va bene, poi ho scritto un bel regex e mi sono reso conto che riconosce che tutti i caratteri UTF8 non sono lettere in .NET ed è stato fregato. Questo sembra essere un problema noto per il motore regex .NET. Quindi sono arrivato a questa soluzione:

private static string GetTitleForUrlDisplay(string title)
{
    if (!string.IsNullOrEmpty(title))
    {
        return Regex.Replace(Regex.Replace(title, @"[^A-Za-z0-9_-]", new MatchEvaluator(CharacterTester)).Replace(' ', '-').TrimStart('-').TrimEnd('-'), "[-]+", "-").ToLower();
    }
    return string.Empty;
}


/// <summary>
/// All characters that do not match the patter, will get to this method, i.e. useful for unicode chars, because
/// .NET impl of regext do not handle unicode chars. So we use char.IsLetterOrDigit() which works nicely and we 
/// return what we approve and return - for everything else.
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
private static string CharacterTester(Match m)
{
    string x = m.ToString();
    if (x.Length > 0 && char.IsLetterOrDigit(x[0]))
    {
        return x.ToLower();
    }
    else
    {
        return "-";
    }
}

Ho trovato molto utile codificare il mio url in uno sicuro quando stavo restituendo un valore tramite ajax / php a un url che è stato poi letto nuovamente dalla pagina.

Uscita PHP con encoder url per il carattere speciale e

//PHP returning the sucess info of ajax request
echo "".str_replace('&','%26',$_POST['name'])." category was changed";

//javascript sending the value to url
window.location.href='time.php?return=updated&val='+msg;

//javascript/php executing the function printing the value of the url,
//now with the text normally lost in space because of the reserved & character.

setTimeout("infoApp('updated','<?php echo $_GET['val'];?>');",360);

Spero che qualcuno trovi utili i miei piccoli estratti di codice! :)

Penso che tu stia cercando qualcosa come "Codifica URL" - codificare un URL in modo che sia "sicuro" da usare sul web:

Ecco un riferimento per questo. Se non desideri caratteri speciali, rimuovi quelli che richiedono la codifica URL:

http://www.w3schools.com/TAGS/ref_urlencode.asp

Tra 3-50 caratteri. Può contenere lettere minuscole, numeri e caratteri speciali: punto (.), Trattino (-), trattino basso (_) e alla velocità (@).