Confronta le richieste con le regole
Perché è importante Un blocker controlla ogni singola richiesta che fa una pagina, spesso più di cento per pagina, contro decine di migliaia di regole. Se quel controllo è lento, ogni pagina sembra lenta, e le persone spengono il blocker. Veloce e corretto è ciò che rende la protezione utilizzabile.
Due lavori: la risposta giusta, in fretta
Pensa a una biblioteca con 5.000 libri. Per trovarne uno, non leggeresti ogni dorso dal primo scaffale. Vai alla sezione giusta, poi allo scaffale giusto. Un blocker dovrebbe fare lo stesso: saltare direttamente alle poche regole che potrebbero corrispondere, e controllare solo quelle.
Questo esercizio viene corretto su entrambe le cose. I test contano quante volte il tuo decide chiama rule_matches per una richiesta, e il budget è di 20 controlli con 5.000 regole caricate. Contiamo i controlli invece di cronometrarti, così un telefono lento e un portatile veloce vengono corretti allo stesso modo.
Passo 1: i caratteri jolly
Carattere jolly: un simbolo che sta per "qualsiasi carattere". Negli elenchi di filtri è *, quindi /beacon/*/hit corrisponde a /beacon/42/hit e a /beacon/abc/hit.
Dividi il pattern a ogni *, poi trova i pezzi nel testo, in ordine, ciascuno dopo il precedente:
wildcard_in("*/collect?*cid=", "https://m.example/collect?x=1&cid=9")
# pieces: "/collect?" then "cid=" -> both found, in order -> True
wildcard_in("a*b", "b then a")
# "a" found at position 7, then no "b" after it -> Falsetext.find(piece, pos) restituisce dove inizia piece, cercando solo dalla posizione pos, oppure -1 se non c'è. Nota che negli elenchi di filtri ? e . sono caratteri normali, quindi non usare un'espressione regolare o fnmatch, che li trattano come speciali.
Passo 2: una regola contro una richiesta
rule_matches(rule, url, third_party) risponde sì o no per una regola:
- Una regola con
third_partyimpostato non corrisponde mai a una richiesta di prima parte. - Una regola di dominio
adco.examplecorrisponde all'hostadco.exampleo a qualsiasi host che finisce con.adco.example. Il punto conta:notadco.exampleè qualcun altro. - Una regola di pattern corrisponde quando
wildcard_in(value, url.lower())è vero.
Passo 3: un indice, così controlli solo poche regole
Indice: una struttura costruita una volta che ti permette di trovare cose senza cercare dappertutto, come l'indice in fondo a un libro. Qui: un dict dal nome dell'host alle regole per quell'host.
Un dict di Python trova una chiave in un passo solo, per quante chiavi contenga. Quindi costruisci, una volta sola:
index = {"domains": {"adco.example": [rule, ...], ...},
"patterns": [rule, rule, ...]}Per una richiesta a img.adco.example, cerca ogni finale dell'host: img.adco.example, adco.example, example. Sono tre ricerche invece di 5.000 controlli. Aggiungi le poche regole di pattern (i blocker veri indicizzano anche quelle, in base a un breve pezzo di testo che devono contenere; noi le teniamo in una semplice lista).
Passo 4: decidi, con le eccezioni che vincono
Controlla ogni candidata. Se una qualsiasi regola che corrisponde è un'eccezione, la risposta è "allow", punto. Altrimenti, se ha corrisposto una regola di blocco, "block"; se non ha corrisposto niente, "allow". Le eccezioni esistono perché gli elenchi a volte catturano cose di cui un sito ha davvero bisogno, come cdn.example, che fornisce una libreria innocua.
Un equivoco comune
"Più regole significano un blocker più lento." Con un buon indice, no: cercare un host in un dict costa più o meno lo stesso con 50 regole o con 50.000. Ciò che rallenta un blocker è controllare le regole una per una.
Provalo Dopo aver superato l'esercizio, cambia decide perché faccia un ciclo su ogni regola dell'elenco (senza indice) ed esegui di nuovo i test. Il test del budget fallisce con un conteggio di circa 5.000. Quel numero è il lavoro che il tuo indice risparmia a ogni richiesta di ogni pagina.
In altri linguaggi
JavaScript:
function wildcardIn(pattern, text) {
let pos = 0;
for (const piece of pattern.split("*")) {
if (!piece) continue;
const at = text.indexOf(piece, pos);
if (at === -1) return false;
pos = at + piece.length;
}
return true;
}
// Index: a Map from host to rules; look up each ending of the host.
function candidates(index, host) {
const parts = host.split(".");
const out = [];
for (let i = 0; i < parts.length; i++) {
out.push(...(index.domains.get(parts.slice(i).join(".")) || []));
}
return out.concat(index.patterns);
}Go:
func wildcardIn(pattern, text string) bool {
pos := 0
for _, piece := range strings.Split(pattern, "*") {
if piece == "" {
continue
}
at := strings.Index(text[pos:], piece)
if at < 0 {
return false
}
pos += at + len(piece)
}
return true
}Riepilogo
- Pattern con caratteri jolly: dividi a
*e trova i pezzi in ordine. - Le regole di dominio corrispondono all'host o a qualsiasi sottodominio, confrontati etichetta per etichetta.
- Un indice (un dict per host) significa poche ricerche invece di migliaia di controlli.
- Un'eccezione che corrisponde vince sempre su una regola di blocco.
Scrivi quattro funzioni. wildcard_in(pattern, text): True quando i pezzi di pattern tra i segni * compaiono tutti in text in ordine. rule_matches(rule, url, third_party): True quando un dict di regola (dalla lezione precedente) corrisponde alla richiesta. build_index(rules): organizza le regole come preferisci perché decide possa saltarne la maggior parte. decide(index, url, third_party): restituisci "block" o "allow", con qualsiasi eccezione che corrisponde che vince, chiamando rule_matches al massimo 20 volte per richiesta quando sono caricate 5.000 regole.
Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione
Questo esercizio si apre presto
Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.