Imagine isso, temos um ambiente com um escopo global contendo apenas um único objeto, chamado codegolf. Este objeto tem um único filho chamado stackexchange, que possui uma propriedade chamada com.
Acessar esta propriedade seria semelhante codegolf.stackexchange.com.

O desafio

A entrada do seu programa / função será uma string tentando acessar uma propriedade no escopo global. Sempre que essa propriedade for encontrada, você deverá imprimir / retornar um valor verdadeiro. Se a propriedade não for encontrada, um valor falso será impresso / retornado. O problema: quando você tenta acessar uma propriedade em um objeto inexistente, seu programa deve gerar qualquer tipo de erro¹.

Para facilitar um pouco as coisas, você pode assumir que a entrada sempre será [a-z.], nunca estará vazia, nunca terá repetições .e nunca começará ou terminará com a .. Assim codegolf.é uma entrada inválida.

Casos de teste

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

Este é o código-golfe , o código mais curto em bytes ganha

¹ se (e somente se) o seu idioma de escolha não suporta erros em tudo , você deve imprimir algo que deixa claro que este é um erro. Por exemplo, se você usar 1 para verdade e 0 para falsidade, poderá usar "e" para um erro. Seja consistente com seus valores de retorno e explique o comportamento em sua postagem.

JavaScript, 135 bytes

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))

Retrabalhada a primeira tentativa de impedir o acesso às chaves internas, neste momento será melhor usar uma abordagem diferente, mas ei!

Retorna verdadeiro para válido, falso para ausente e erros em erro.

JavaScript (ES6), 87 bytes

Retorna false/ trueou joga 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

Versão probabilística, 78 bytes (não concorrente)

Como todas as propriedades são garantidas para corresponder [a-z] , podemos tentar:

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

Além do fato de 587ser primo e levar a valores bastante curtos para as palavras em que estamos interessados, essa é uma opção de módulo bastante aleatória.

Embora seja aprovado em todos os casos de teste, é provável que retorne falsos positivos.

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

Lote, 269 231 bytes

@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

Recebe entrada em STDIN; gera um erro de sintaxe para uma propriedade inválida. Funciona usando wcomo uma máquina de estado. Se wterminar com um, .significa que o próximo acesso à propriedade é inválido. Editar: salvou 17 bytes usando o erro de sintaxe para abortar o script em lote. Economizei 21 bytes ao perceber que uma de minhas atribuições pode ser incondicional.

Javascript, 84 82 bytes

Não é curto o suficiente para vencer, mas, como sou iniciante, pensei que seria divertido compartilhá-lo. Talvez alguém tenha uma sugestão de melhoria.

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

Ele passa em todos os testes da pergunta, retorna truepara o valor existente,false para inexistente e gera um erro se você tentar obter uma propriedade de uma variável inexistente ou sem objeto. No entanto, agora percebo que esta solução também apresenta alguns problemas. Conforme apontado por @Florent nos comentários, ele retorna true quando propriedades de protótipo de string, como .toStringsão chamadas.

Editar : 2 bytes mais curto graças a @MamaFunRoll

Snippet de teste:

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 bytes

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}

Funciona com o IE 10, portanto, deve funcionar nos principais navegadores modernos.

Experimente aqui (+ não destruído)

C #, 155 bytes

Não seria o mais curto, mas achei que seria divertido tentar em 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;}

• Divide a string e inverte a iteração no resultado.
• Um elemento não correspondente com mais de uma iteração profunda, erros (lançando um IndexOutOfRangeException acessando um caracter na posição -1 na sequência).
• Caso contrário, retornará false se algum elemento não corresponder.

.NET Fiddle

Ruby, 84 80 bytes

Função anônima que retorna trueou false, ou divide por zero para gerar erro:

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

Experimente online

C, 98 112 113 bytes

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

destroçado

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

para o abaixo tem que seg falha

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

Java, 187 138 bytes

Versão 2.0 ( 138 bytes): Idéia roubada descaradamente do @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;}

Versão 1.0 ( 187 bytes):

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]);}

Explicação da peça de devolução:

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