La meilleure façon de vérifier qu'une ad resse existe?

Bonjour,

Ce n’est pa vraiment une question concernant rails, mais j’aimerai
savoir quelle serait la meilleure façon de vérifier qu’une adresse
entrée par un utilisateur ressemble a une adresse déjà dans la base.
Il y a 3 champs discriminant le pays, le numéro et le code postal que
je vais tester mais comment faire exactement pour la partie littérale
de l’adresse “Charles de Gaulle” est similiare “Général Charles de
Gaulle”, “Saint Antoine” est similaire à “st Antoine”.

Je pensais au moyen d’une expression régulière extraire tous les mots
de l’adresse (en enlevant les “de”, “le”, “la”, …) et ensuite
chercher dans ma base avec des :condition => ‘like ?’

Mais j’ai peur que ce ne soit pas trop performant.
Qu’en pensez vous? Avez vous d’autres idées?

Merci d’avance

Bonjour Tranquiliste,

Personnellement, je ne vois pas la nécessité de vérifier une adresse
postale, et même en prenant ce point comme une obligation, tu risques
plus
de faux négatifs que de vrai négatifs. Les typos sont courantes dans les
adresses: de grandes sociétés ont soit des catalogues de nom de rues
dans
les communes de plusieurs pays, soit des correcteur heuristique qui font
des
horreurs (pour ces derniers, mon adresse de jeunesse qui était “allée du
marais” se transformait presque systématique en “allée du morois”, va
savoir
pourquoi.

Si ton inquiétude est qu’un colis ou un pli n’arrive pas à destination,
rappelle toi que les facteurs connaissent bien leur métier et leur
secteur:
ils corrigent assez facilement d’eux-même les erreurs de typos. Si tu
veux
que l’adresse soit “parfaitement” écrite, tu risques de perdre des
ventes/contacts parce que ton système de vérif va refuser une adresse
valide, tout simplement parce qu’il n’aura pas le dernier renommage
d’une
rue d’une commune ou que ta liste comportera une faute…

Désolé de ne pas te proposer de solution: je pense tout simplement qu’il
n’en existe pas.

Bon courage.

Le 2 juillet 2008 17:14, Tranquiliste [email protected] a écrit
:

En fait je me suis mal exprimé, je ne cherche pas vraiment à vérifier
les adresses à 100%, je veux simplement (dans certains cas) pouvoir
proposer à l’utilisateur les adresses “similaires” qui sont déjà dans
la base après c’est à lui de choisir si une autre lui convient mieux.

L’un des trucs les plus ergonomiques pour ça c’est peut-être de faire
des
suggestions AJAX.

  • c’est pas trop chargeant en BDD si on met un timeout pas trop
    rapide
    pour activer la suggestion
  • c’est pratique pour l’utilisateur qui voit tout de suite s’il
    existe
    une adresse qui commence pareil que ce qu’il tape
  • ca évite de devoir demander à -posteriori “tiens, et si finalement
    vous
    ne vouliez pas dire ça qui ressemble beaucoup ?” une fois le bouton
    “valider” cliqué

Après c’est mon avis (et je le partage).

tu peux peut-être jeter un oeil aux implementations des algorithme de
similarité (ca se dit ça?) entre chaines
http://raa.ruby-lang.org/project/levenshtein/
http://raa.ruby-lang.org/project/soundex/
et http://en.wikipedia.org/wiki/Damerau-Levenshtein_distance

Vincent

Tranquiliste wrote:

En fait je me suis mal exprim�, je ne cherche pas vraiment � v�rifier
les adresses � 100%, je veux simplement (dans certains cas) pouvoir
proposer � l’utilisateur les adresses “similaires” qui sont d�j� dans
la base apr�s c’est � lui de choisir si une autre lui convient mieux.

Une solution pourrait etre d’utiliser Ferret.

Merci à tous pour vos commentaires.

Vincent : c’est intéressant ces algorithmes, je ne connaissais pas
(les projets ont l’air vieux mais je vais jeter un coup d’oeil)
Michel : j’ai peur que l’auto-complete (si c’est de ça dont tu parles)
ne fonctionne pas dans mon cas si l’utilisateur commence à rentrer
“st” il n’aura pas les adresses avec “saint”.
Tony : c’est peut être une bonne idée, d’autant plus que je vais avoir
besoin de ferret par ailleurs pour ce projet

En tout cas, j’ai de quoi réfléchir.

Merci encore

si l’utilisateur commence à rentrer “st” il n’aura pas les adresses avec
“saint”.

Voici une méthode de mon cru pour reconstituer des noms de patelin sans
ambiguité.

Si ça peut te servir (et c’est certainement améliorable)

N.B. les “_” pourraientêtre rempacés par des espaces, c’est juste que je
stocke comme ça dans ma table “villes”

def self.canonicalize( text )

 if text
   canon =

text.gsub(/\s*[sS][tT][eE]\s*|\s*[sS][tT]\s*|\s*[sS][sS]\s*|\s*/\s*|\s*-\s*|\s*\’\s*|\s+|./)
do |match|
case match
when /\s*[sS][tT][eE]\s*/ then ‘sainte
when /\s*[sS][tT]\s*/ then ‘saint
when /\s*[sS][sS]\s*/ then ‘sous
when /\s*/\s*/ then ‘sur
when /\s*-\s*/ then ‘
when /\s+/ then '

when /\s*\’\s*/ then ‘_’ # TODO : look
closer
???
when /[à âä]/ then ‘A’
when /[éêè]/ then ‘E’
when /[ùûü]/ then ‘U’
when /[ôö]/ then ‘O’
when /[ç]/ then ‘C’
when /[a-zA-Z]/ then match
end
end

  canon.gsub!( /^_+/ , '' )
  canon.gsub!( /_+$/ , '' )
  canon.upcase!
  return canon
else
      return ''
end

end

def self.canon2text( text )
text.gsub( /_/ , ’ ’ )
end


IciMarché fédère l’e-commerce de proximité
http://icimarche.fr

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs