Imaginez cela, nous avons un environnement avec une portée globale contenant un seul objet, appelé codegolf. Cet objet a un seul enfant appelé stackexchange, qui a une propriété appelée com.
Accéder à cette propriété ressemblerait codegolf.stackexchange.com.

Le défi

L'entrée de votre programme / fonction sera une chaîne essayant d'accéder à une propriété sur la portée globale. Chaque fois que cette propriété est trouvée, vous devez imprimer / retourner une valeur véridique. Si la propriété n'est pas trouvée, une valeur falsifiée doit être imprimée / retournée. Le hic: lorsque vous essayez d'accéder à une propriété sur un objet inexistant, votre programme doit lancer n'importe quel type d'erreur¹.

Pour rendre les choses un peu plus faciles, vous pouvez supposer que l'entrée sera toujours [a-z.], elle ne sera jamais vide, elle n'aura jamais de répétition .et elle ne commencera ni ne se terminera jamais par a .. Il en codegolf.va de même pour une entrée non valide.

Cas de test

codegolf.stackexchange.com => 1 // or any other truthy value
codegolf.stackexchange.net => 0 // or any other falsy value
codegolf.stackexchange => 1
codegolf.foo => 0
codegolf => 1
foo => 0
codegolf.com => 0
codegolf.constructor => 0

codegolf.foo.bar => Error (since foo is undefined)
codegolf.stackexchange.com.foo => Error (since com is a value, not an object)
codegolf.stackexchange.com.foo.bar => Error
foo.stackexchange.com => Error
foo.bar => Error
foo.bar.baz => Error

Ceci est le code-golf , le code le plus court en octets gagne

¹ si (et seulement si) langue de votre choix ne supporte pas les erreurs du tout , vous devez quelque chose de sortie qui le rend clair que cela est une erreur. Par exemple, si vous utilisez 1 pour la vérité et 0 pour la fausse, vous pouvez utiliser "e" pour une erreur. Soyez cohérent dans vos valeurs de retour et expliquez le comportement dans votre message.

JavaScript, 135 octets

v=>(c=(p,i)=>new Proxy({}, {get:(o,q)=>(r=q==p[i]?c(p,i+1):o.$,i==3?r||z:r)}),x=c(["codegolf","stackexchange","com"],0),!!eval("x."+v))

Retravaillé la première tentative pour empêcher l'accès aux clés intégrées, à ce stade, il vaudrait mieux utiliser une approche différente, mais bon!

Renvoie vrai pour valide, faux pour manquant et erreurs sur erreur.

JavaScript (ES6), 87 octets

Renvoie false/ trueou jette ReferenceError.

s=>s.split`.`.map((w,i)=>e|['codegolf','stackexchange','com'][i]!=w&&e++,e=0)&&e>1?X:!e

let f =
    
s=>s.split`.`.map((w,i)=>e|['codegolf','stackexchange','com'][i]!=w&&e++,e=0)&&e>1?X:!e

console.log(f('codegolf.stackexchange.com')); // => true
console.log(f('codegolf.stackexchange.net')); // => false
console.log(f('codegolf.stackexchange'));     // => true
console.log(f('codegolf.foo'));               // => false
console.log(f('codegolf'));                   // => true
console.log(f('foo'));                        // => false
console.log(f('codegolf.com'));               // => false

console.log(f('codegolf.foo.bar'));           // => Error

Version probabiliste, 78 octets (non concurrent)

Parce que toutes les propriétés sont garanties pour correspondre [a-z], nous pouvons essayer ceci:

s=>s.split`.`.map((w,i)=>e|[162,6,2][i]-parseInt(w,36)%587&&e++,e=0)&&e>1?X:!e

Mis à part le fait que 587c'est un nombre premier et conduit à des valeurs plutôt courtes pour les mots qui nous intéressent, c'est un choix modulo plutôt aléatoire.

Bien qu'il réussisse tous les cas de test, il est bien sûr susceptible de renvoyer des faux positifs.

let f =
    
s=>s.split`.`.map((w,i)=>e|[162,6,2][i]-parseInt(w,36)%587&&e++,e=0)&&e>1?X:!e

console.log(f('codegolf.stackexchange.com')); // => true
console.log(f('codegolf.stackexchange.net')); // => false
console.log(f('codegolf.stackexchange'));     // => true
console.log(f('codegolf.foo'));               // => false
console.log(f('codegolf'));                   // => true
console.log(f('foo'));                        // => false
console.log(f('codegolf.com'));               // => false

console.log(f('codegolf.foo.bar'));           // => Error

Lot, 269 231 octets

@echo off
set/ps=
set w=1codegolf
for %%a in (%s:.= %)do call:l %%w
echo %w:~0,1%
exit/b
:g
if
:l
if %w:~-1%==. goto g
if not %1==%w% set w=0.&exit/b
set w=1com
if %1==com set w=1.
if %1==codegolf set w=1stackexchange

Prend entrée sur STDIN; renvoie une erreur de syntaxe pour une propriété non valide. Fonctionne en utilisant wcomme une machine d'état. Si wse termine par un, .cela signifie que le prochain accès à la propriété n'est pas valide. Modifier: 17 octets enregistrés en utilisant l'erreur de syntaxe pour abandonner le script de commandes. Enregistré 21 octets en réalisant que l'une de mes affectations pourrait être inconditionnelle.

Javascript, 84 82 octets

Pas assez court pour gagner, mais depuis que je suis débutant, j'ai pensé que ce serait amusant de le partager. Peut-être que quelqu'un a une suggestion d'amélioration.

s=>s.split`.`.length>3&&e||!!eval('codegolf={stackexchange:{com:true}};window.'+s)

Il passe tous les tests de la question, retourne truepour la valeur existante, falsepour inexistant et il renvoie une erreur si vous essayez d'obtenir une propriété d'une variable inexistante ou non objet. Cependant, je me rends compte maintenant que cette solution présente également certains problèmes. Comme indiqué par @Florent dans les commentaires, il renvoie true lorsque des propriétés de prototype de chaîne telles que .toStringsont appelées.

Edit : 2 octets plus court grâce à @MamaFunRoll

Extrait de test:

var f =
s=>s.split`.`.length>3&&e||!!eval('codegolf={stackexchange:{com:true}};window.'+s)

console.log(f('codegolf.stackexchange.com')) //true
console.log(f('codegolf.stackexchange.net')) //false
console.log(f('codegolf.stackexchange')) //true
console.log(f('codegolf.foo')) //false
console.log(f('codegolf')) //true
console.log(f('foo')) //false
console.log(f('codegolf.com')) //false

console.log(f('codegolf.foo.bar')) // TypeError
console.log(f('codegolf.stackexchange.com.foo')) //ReferenceError
console.log(f('codegolf.stackexchange.com.foo.bar')) //ReferenceError
console.log(f('foo.stackexchange.com')) // TypeError
console.log(f('foo.bar')) // TypeError
console.log(f('foo.bar.baz')) // TypeError

JavaScript, 173 octets

function d(a){var b="codegolf",u="stackexchange",c=a.split("."),e="e";return c.length==1?c[0]==b:c.length==2?c[0]==b?c[1]==u:e:c.length==3?c[0]==b?c[1]==u?c[2]=="com":e:e:e}

Fonctionne avec IE 10, devrait donc fonctionner sur les principaux navigateurs modernes.

Essayez-le ici (+ non golfé)

C #, 155 octets

N'allait pas être le plus court mais pensait que ce serait amusant d'essayer en C # ...

bool f(string s){var a=s.Split('.');int e=0,l=a.Length-1,i=l;for(;0<=i;i--){e+=a[i]!=new[]{"codegolf","stackexchange","com"}[i]?i<l?s[-1]:1:0;}return e<1;}

• Fractionne la chaîne et inverse itère le résultat.
• Un élément non correspondant à plus d'une itération en profondeur, des erreurs (lancer un IndexOutOfRangeExceptionen accédant à un char à -1 position dans la chaîne).
• Sinon, renvoie false si aucun élément ne correspond.

.NET Fiddle

Rubis, 84 80 octets

Fonction anonyme qui renvoie trueou false, ou divise par zéro pour générer une erreur:

->s{k=1;s.split(?.).zip(%w[codegolf stackexchange com]){|i,o|1/0if !k;k=i==o};k} 

Essayez-le en ligne

C, 98 112 113 octets

f(char*a){char*c="codegolf.stackexchage.com";while(*c&&*c==*a)++a,++c;return strchr(a,46)?*(a=0):!(*a|*c&*c-46);}

non golfé

f(char*a){char*c="codegolf.stackexchage.com";
          while(*c&&*c==*a)++a,++c;
          return strchr(a,46)?*(a=0):!(*a|*c&*c-46);
         }

f(codegolf.stackexchage.com)=1
f(codegolf.stackexchage.net)=0
f(codegolf.stackexchage)=1
f(codegolf.foo)=0
f(codegolf)=1
f(foo)=0

pour le ci-dessous, il doit seg faute

f(codegolf.stackexchage.com.foo)
f(foo.bar)
f(foo.bar.baz)
f(codegolf.foo.bar)
f(foo.v)

Java, 187138 octets

Version 2.0 ( 138 octets): Idée volée sans vergogne à @Jamie.

l->{for(String []a=l.split,int l=i=a.length-1,e=0;i>=0;e+=a[i]!=new String[]{"codegolf","stackexchange","com"}[i]?i<l?s[-1]:1:0)return e;}

Version 1.0 ( 187 octets):

l->{String[]a=l.split(".");return a[0].equals("codegolf")?(a.length<2?1:(a[1].equals("stackexchange")?(a.length<3?1:(a[2].equals("com")?1:0)):(a.length<3?0:a[-1]))):(a.length<2?0:a[-1]);}

Explication de la partie retour:

return a[0].equals("codegolf")?(a.length<2?1:(a[1].equals("stackexchange")?(a.length<3?1:(a[2].equals("com")?1:0)):(a.length<3?0:a[-1]))):(a.length<2?0:a[-1]);
return                                                                                                                                                        ;
       a[0].equals("codegolf")?                                                                                                          :
                               (a.length<2? :                                                                                           ) (a.length<2? :     )
                                           1 (a[1].equals("stackexchange")?                                       :                    )              0 a[-1]
                                                                           (a.length<3? :                        ) (a.length<3? :     )
                                                                                       1 (a[2].equals("com")? : )              0 a[-1]
                                                                                                             1 0