Comment analyser une URL?

Si il y a une chose que j'ai juste ne peux pas obtenir ma tête autour de, il est regex.

Donc, après beaucoup de recherche j'ai enfin trouvé celui qui convient à mes besoins:

function get_domain_name()
    { 
    aaaa="http://www.somesite.se/blah/sdgsdgsdgs";
    //aaaa="http://somesite.se/blah/sese";
        domain_name_parts = aaaa.match(/:\/\/(.[^/]+)/)[1].split('.');
        if(domain_name_parts.length >= 3){
            domain_name_parts[0] = '';
        }
        var domain = domain_name_parts.join('.');
        if(domain.indexOf('.') == 0)
            alert("1"+ domain.substr(1));
        else
            alert("2"+ domain);
    }

Fondamentalement, ça me redonne le nom de domaine, est-il de toute façon je peux aussi obtenir tous les trucs après le nom de domaine? dans ce cas, il serait /blah/sdgsdgsdgs de la aaaa variable.

Une bonne ressource pour apprendre les regex: regular-expressions.info
Donc, vous voulez le chemin, pas le domaine?

InformationsquelleAutor Ryan | 2011-05-29

javascript regex

3

Veuillez noter que cette solution n'est pas la meilleure. J'ai fait cela juste pour correspondre aux exigences de l'OP. Personnellement, je suggère de regarder dans les autres réponses.

Suivantes regexp va vous redonner le domaine et le reste. :\/\/(.[^\/]+)(.*):
1. http://www.google.com
2. /goosomething
Je vous suggère d'étudier l'expression de la documentation ici: http://www.regular-expressions.info/reference.html

À l'aide de votre fonction:
```
function get_domain_name()
    { 
    aaaa="http://www.somesite.se/blah/sdgsdgsdgs";
    //aaaa="http://somesite.se/blah/sese";
        var matches = aaaa.match(/:\/\/(?:www\.)?(.[^/]+)(.*)/);
        alert(matches[1]);
        alert(matches[2]);
    }
```
- peut alert(matches[1]); return sans le "www."? alert(matches[2]); est parfait! Et merci pour le lien.
- Mis à jour en fonction de vos besoins.
- Juste ce que j'ai demandé, merci! (Merci tout le monde qui y a répondu à aussi bien!)
- ne pouvez-vous pas de re-définir la "accepté" une solution le plus de votes? Je suis sûr que vous pouvez le faire...
InformationsquelleAutor MarioRicalde
72

Au lieu de compter sur une potentiellement peu fiables* regex, vous devriez plutôt utiliser le haut-URL de l'analyseur que le JavaScript API DOM fournit:
```
var url = document.createElement('a');
url.href = "http://www.example.com/some/path?name=value#anchor";
```
C'est tout ce que vous devez faire pour analyser l'URL. Tout le reste est juste accès à l'valeurs analysées:
```
url.protocol; //(http:)
url.hostname; //(www.example.com)
url.pathname; //(/some/path)
url.search; //(?name=value)
url.hash; //(#anchor)
```
Dans ce cas, si vous êtes à la recherche pour /blah/sdgsdgsdgs, vous devez accéder avec url.pathname

Fondamentalement, vous avez juste à créer un lien (techniquement, élément ancre) en JavaScript, et puis vous pouvez faire des appels à l'analyse des pièces directement. (Puisque vous n'êtes pas à l'ajouter à DOM, il ne pas ajouter des liens invisibles, n'importe où). On y accède de la même manière que les valeurs de la location objet.

(Inspiré par cette merveilleuse réponse.)

EDIT: Une remarque importante: il semble que Internet Explorer a un bug où il omet le slash sur le pathname attribut sur les objets de ce genre. Vous pourrait normaliser en faisant quelque chose comme:
```
 url.pathname = url.pathname.replace(/(^\/?)/,"/");
```
Note:
*: Je dis "potentiellement non fiables", car il peut être tentant d'essayer de construire ou de trouver un ensemble englobant l'URL de l'analyseur, mais il y a beaucoup, beaucoup de conditions, en cas de bord et de pardonner à l'analyse des techniques qui pourraient ne pas être considérés comme correctement pris en charge; les navigateurs sont probablement les plus efficaces à mettre en œuvre (depuis l'analyse des Url est essentielle à leur bon fonctionnement) cette logique, nous devrions rester simple et de laisser à leur.
- Une peine de note de bas de page: La seule fois où je l'ai trouvé ceci pour ne pas être une bonne méthode si vous êtes de l'analyse d'un grand nombre de liens; DOM élément de la création est plus cher que juste regex. À un petit nombre, la différence est indiscernable. À 100+, il peut avoir des effets notables.
- Bon appel sur la normalisation de la pathname! Êtes-vous sûr il n'y a pas d'effets secondaires de la ré-affectation de l'normalisé pathname? Aussi, pourrais-je vous recommandons de retirer la () de la regex?
- de donner ce travail à l'navigateur est comme: j'espère que le navigateur est-il correctement... comme vous l'avez mentionné, l'IE bug peut être un problème
- Est que le code couvert par le JavaScript DOM liaison standard? - Je n'ai pas trouver encore.
InformationsquelleAutor Yahel
27

La RFC (voir l'annexe B) fournit une expression régulière pour analyser l'URI de pièces:
```
^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
 12            3  4          5       6  7        8 9
```
où
```
scheme    = $2
authority = $4
path      = $5
query     = $7
fragment  = $9
```
Exemple:
```
function parse_url(url) {
    var pattern = RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?");
    var matches =  url.match(pattern);
    return {
        scheme: matches[2],
        authority: matches[4],
        path: matches[5],
        query: matches[7],
        fragment: matches[9]
    };
}
console.log(parse_url("http://www.somesite.se/blah/sdgsdgsdgs"));
```
donne
```
Object
    authority: "www.somesite.se"
    fragment: undefined
    path: "/blah/sdgsdgsdgs"
    query: undefined
    scheme: "http"
```
DÉMO
- Vous pouvez améliorer l'expression régulière en utilisant des groupes non capturés.
- Je pense que je dois apprendre regex correctement avant que je puisse comprendre votre post mate, même si je suis sûr qu'il est extrêmement utile.
- Avec non-capture de groupes: "^(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(\\?(?:[^#]*))?(#(?:.*))?". Retourne seul schéma, d'accueil, de chemin d'accès, d'interrogation et de fragment. Remarque: :// ne fait pas partie du système, car le système peut effectivement être omis.
- C'est dope af! Merci pour relier les RFC. De vrais héros, ceux des auteurs.
- En outre, je voudrais ajouter, comment faire pour obtenir l'URI en cours: document.URL et comment analyser la requête: stackoverflow.com/a/2091331/1069083
- Soyez prudent lors de la copie de la marque, solution de son commentaire. Invisible de caractères UTF-8 est copié à cause du saut de ligne. J'ai perdu une heure à comprendre pourquoi le fragment-partie ne fonctionne pas. Commutation de l'encodage ANSI dans Notepad++ résolu ce mystère
InformationsquelleAutor Felix Kling
2

Vous avez juste besoin de modifier votre regex un peu. Par exemple:
```
var aaaa="http://www.somesite.se/blah/sdgsdgsdgs";
var m = aaaa.match(/^[^:]*:\/\/([^\/]+)(\/.*)$/);
```
m contiendra les pièces suivantes:
```
["http://www.somesite.se/blah/sdgsdgsdgs", "www.somesite.se", "/blah/sdgsdgsdgs"]
```
Voici le même exemple, mais modifié, de sorte qu'il se divise, les "www." partie. Je pense que l'expression régulière doit être écrit afin que le match va travailler si vous pouvez ou non vous avez le "www." partie. Afin de vérifier cela:
```
var aaaa="http://www.somesite.se/blah/sdgsdgsdgs";
var m = aaaa.match(/^[^:]*:\/\/(www\.)?([^\/]+)(\/.*)$/);
```
m contiendra les pièces suivantes:
```
["http://www.somesite.se/blah/sdgsdgsdgs", "www.", "somesite.se", "/blah/sdgsdgsdgs"]
```
Maintenant, découvrez la même expression régulière, mais avec une url qui ne commence pas par "www.":
```
var bbbb="http://somesite.se/blah/sdgsdgsdgs";
var m = .match(/^[^:]*:\/\/(www\.)?([^\/]+)(\/.*)$/);
```
Maintenant votre match ressemble à ceci:
```
["http://somesite.se/blah/sdgsdgsdgs", undefined, "somesite.se", "/blah/sdgsdgsdgs"]
```
Donc, comme vous pouvez le voir, il va faire la bonne chose dans les deux cas.
- Hey! Merci pour la réponse! Non, j'ai besoin de la deuxième partie, sans le "www." exactement comme dans l'original. Et la deuxième partie comme vous avez écrit ci-dessus. Merci!
- EDIT; je voulais dire: Non, j'ai besoin de la deuxième partie, sans le "www." exactement comme dans l'original. Et la troisième partie comme vous avez écrit ci-dessus est parfait. Merci!
InformationsquelleAutor gordyt

Il y a une belle plugin jQuery pour analyser les Url: Purl.

Tous les regex choses est caché à l'intérieur, et vous obtenez quelque chose comme:

> url = $.url("http://markdown.com/awesome/language/markdown.html?show=all#top");

> url.attr('source');
"http://markdown.com/awesome/language/markdown.html?show=all#top"

> url.attr('protocol');
"http"

> url.attr('host');
"markdown.com"

> url.attr('relative');
"/awesome/language/markdown.html?show=all#top"

> url.attr('path');
"/awesome/language/markdown.html"

> url.attr('directory');
"/awesome/language/"

> url.attr('file');
"markdown.html"

> url.attr('query');
"show=all"

> url.attr('fragment');
"top"

InformationsquelleAutor weekens

Vous devez vous connecter pour publier un commentaire.