Utilização de VBScript e JScript numa página Web

Microsoft Corporation

Tradução de Leonel Morgado, para uso interno da equipa de programação do SCETAD.

A versão original desta página, em inglês, encontra-se em http://msdn.microsoft.com/library/techart/msdn_vbnjscrpt.htm.

Terminologia utilizada:

Setembro de1998

Resumo: exposição das diferenças entre VBScript e JScript, indicando quando é que cada uma é mais adequada. (11 páginas após impresso.) Aborda-se também:

Ao escrever uma página web, chega-se à conclusão de que é necessário introduzir uma sequência de comandos. Felizmente, pode-se escolher de entre várias linguagem interpretadas. Contudo, a exsitência de várias opções coloca no programador a responsabilidade da escolha. O que fazer?

Ou então, suponha-se que é necessário dar seguimento a uma página, escrita com uma linguagem interpretada diferente da utilizada normalmente. É necessário aprender essa linguagem, apenas para acrescentar algumas funcionalidades?

Neste artigo, abordarei estas duas questões. Em primeiro lugar, apresentarei algumas linhas gerais de trabalho com as duas linguagens interpretadas disponibilizadas pela Microsoft:

Há mais linguagens interpretadas sequencais para a Web, como o Perl e o Rexx. No entanto, neste artigo focarei as duas para as quais a Microsoft fornece de origem no Internet Explorer e no Internet Information Server (IIS) um motor ActiveX® para linguagens interpretadas.

Seguidamente, irei expor as ocasiões em que pode desejar ou precisar de utilizar ambas as linguagens na mesma página (como verá, tal é perfeitamente prático). Para o auxiliar, disponibilizarei informações acerca de algumas pequenas questões que deve ter presentes nesta situação.

Por forma a abranger toda esta temática, abordarei:

As diferenças entre VBScript e JScript

A diferença mais óbvia entre o VBScript e o JScript é a respectiva sintaxe. O VBScript é um subconjunto do Visual Basic—que lhe parecerá muito familiar se alguma vez tiver utilizado o Visual Basic ou o Visual Basic for Applications (VBA). No entanto, não é exactamente igual a nenhuma destas linguagens. Como o VBScript foi concebido especificamente para trabalhar em navegadores, não inclui funcionalidades que são normalmente excluídas das sequências de comandos, como o acesso a ficheiros ou os serviços de impressão.

Já o JScript deriva do grupo de linguagens que inclui o C, o C++ e o Java. Quem já trabalhou com C ou com Java vai considerar familiar a sintaxe do JScript. Mas mesmo para aqueles que não conhecem estas linguagens, a sintaxe do JScript não é difícil — possui grande parte da coerência do C e do Java, sem ter toda a complexidade das mesmas.

Nota   Independentemente da forma de como as livrarias possam organizar as estantes de informática, o JScript e o Java são linguagens completamente diferentes. O Java é uma linguagem completa de desenvolvimento, tanto para aplicações na Web como fora dela. Tal não se verifica com o JScript: trata-se de uma linguagem interpretada, relativamente leve, que se emprega essencialmente para definição de sequências de comandos para automação de páginas Web.

O JScript e o VBScript almejam o mesmo objectivo — permitir a definição de sequências de comandos nas páginas Web pages. Cada uma destas linguagens suporta algumas funções que a outra não possui. Mas é provável que estas diferenças, por si, não justifiquem a opção automática por uma linguagem em detrimento da outra.

É muito mais natural que a escolha da linguagem interpretada se baseie noutros factores. Como factor isolado, o principal é também o mais pragmático: a linguagem escolhida é suportada na plataforma a utilizar? As sequências de comandos destinam-se ao cliente ou ao servidor? E que software de navegação ou de servidor possuem os utilizadores?

As secções seguintes apresentam mais pormenores relativamente às duas linguagens interpretadas, além de sugerirem algumas linhas directoras para a escolha, em circunstâncias concretas.

Situações em que se deve optar pelo VBScript

O VBScript é suportado, essencialmente, pelas plataformas da Microsoft. No momento em que foi escrito este artigo, quem deseja utilizar VBScript tem de estar a utilizar um dos seguintes produtos:

Os utilizadores do Visual InterDev já se encontram, quase de certeza, a utilizar o IIS (ou software equivalente), pelo que a utilização do VBScript para sequências de comandos no servidor não constitui qualquer problema. Quem não está a utilizar o IIS deve certificar-se de que o servidor possui suporte para VBScript.

Contudo, a restrição ao Internet Explorer para sequências de comandos no cliente pode constituir um problema, quando se está a criar um sítio Web público, onde não é possível controlar qual o navegador utilizado pelos visitantes. Por isso, a utilização do VBScript só é prática, nas sequências de comandos no cliente, quando se programa para um público cujo navegador conhecemos, como no caso de uma intranet empresarial.

Quem determina que a plataforma-alvo pode suportar VBScript, deve considerar os seguintes factores para decidir se cada sequência de comandos deve ser escrita em VBScript:

Situações em que se deve optar pelo JScript

O JScript é suportado por praticamente todos os navegadores que permitem sequências de comandos. É portanto uma escolha natural para sequências de comandos no cliente, para quem escreve aplicações de grande divulgação, num sítio Web público. Geralmente constata-se também que devido à grande divulgação do JScript (e do seu parente JavaScript) como linguagem normalizada de escrita de sequências de comandos, existem muitas fontes de recursos de apoio disponíveis, tanto nas livrarias como na Web.

Quem deseja utilizar o JScript para sequências de comandos no servidor deve verificar se o servidor o suporta. O IIS permite a utilização de JScript para sequências de comandos nas páginas ASP, mas tal não se verifica em todos os servidores.

Outros factores podem influenciar a decisão de utilização de JScript. Entre estes incluem-se:

Existe uma dificuldade no trabalho com JScript: Distingue maiúsculas de minúsculas, situação a que pode ser dificil de se habituar o programador que só trabalhou em Visual Basic ou VBScript.

Para quem não tem experiência com JScript, interessa mencionar que se deve estudar a forma de criação de rotinas de tratamento de eventos nesta linguagem. No Internet Explorer, o JScript exige que se ligue explicitamente um objecto à respectiva rotina de tratamento de eventos. Normalmente, tal procedimento consiste em especificar atributos na anotação do objecto, que identificam o evento e função de tratamento a que este deve ser vinculado, como se pode ver no exemplo seguinte:

<BUTTON ID="botGuardar" LANGUAGE="JavaScript" onclick="botGuardar_onclick()">

Noutros anfitriões, pode ser possível utilizar vinculação de eventos implícita, mas tal obriga a uma sintaxe ligeiramente diferente à do VBScript. A convenção para rotinas implícitas de tratamento de eventos no JScript é:

<SCRIPT LANGUAGE="JavaScript">
function botGuardar::onclick(){
// sequência de comandos
}
</SCRIPT>

Note-se que em ambos os exemplos o atributo LANGUAGE é definido como "JavaScript." Enquanto que para o Internet Explorer é indiferente a indicação das linguagens "JScript" e "JavaScript", muitos outros navegadores compreendem "JavaScript" mas não "JScript". Para maiores garantias, deve-se utilizar "JavaScript" sempre que não se tem a certeza de que a página será visualizada no Internet Explorer.

Para mais pormenores acerca da criação de rotinas de tratamento de eventos no JScript, deve-se consultar a documentação do Microsoft Visual InterDev, no CD da biblioteca da MSDN.

Forma de especificação de linguagens interpretadas no Visual InterDev

Independetemente da linguagem interpretada que se utiliza, tem de se especificar a linguagem, para que o anfitrião saiba qual o motor de interpretação a utilizar para processar a sequência de comandos. O método exacto a utilizar depende da forma de trabalho: sequências de comandos no servidor, entremeadas com o código da página, ou blocos <SCRIPT> (tanto para sequências de comando de cliente como para as de servidor). Depende também da versão do Visual InterDev que se está a utilizar.

Definição da linguagem para sequências de comandos no servidor, entremeadas

Quem utiliza o IIS e páginas ASP, pode escrever dois tipos de sequências de comandos no servidor: entremeadas (sequências de comandos delimitadas por <% %>) e dentro de elementos <SCRIPT>. Geralmente, as sequências entremeadas permitem a inclusão dos resultados no fluxo HTML da página. Já as sequências em elementos <SCRIPT> são utilizadas para criar funções e subrotinas utilizadas pelas sequências entremeadas.

Nota   É possível criar nos elementos <SCRIPT> sequências que sejam executadas como se estivessem entremeadas — ou seja, cujos comandos não sejam parte de uma função ou subrotina. No entanto, esta prática não é recomendada. A secção "Ordem de execução das sequências de comandos no servidor", neste artigo, apresenta mais pormenores.

A definição da linguagem dos elementos <SCRIPT> é idêntica, tanto para as sequências de servidor como para as de cliente. A secção "Definição da linguagem de um elemento <SCRIPT>", neste artigo, apresenta mais pormenores.

Todas as sequências entremeadas numa página têm de estar na mesma linguagem. Ao criar-se uma nova página ASP, esta inclui automaticamente uma directiva @, que define a linguagem interpretada das sequências entremeadas. A directiva @ pode assemelhar-se a:

<%@ Language="VBScript" %>

A directiva @ tem de ser o primeiro comando da sequência entremeada existente na página. Se estiver ausente, o IIS considera por predefinição que a linguagem das sequências de comandos entremeadas é o VBScript.

Para alterar a linguagem das sequências de comandos entremeadas numa página

Também é possível alterar a predefinição para todas as páginas ASP novas. Esta alteração não actualiza as páginas já existentes, mas sim todas as que forem criadas posteriormente.

Para alterar a linguagem predefinida das sequências de comandos entremeadas

Definição da linguagem de um elemento <SCRIPT>

Ao contrário das sequências de comandos entremeadas do servidor, a linguagem interpretada utilizada nos elementos <SCRIPT> pode variar dentro da página. Um bloco pode estar em VBScript, outro em JScript. (É de recordar que nem todas as plataformas suportam VBScript.)

Nota   É possível obter apontamentos relativamente a pormenores a ter em atenção, quando se misturam linguagens interpretadas, na secção "Utilização de ambas as linguagens na mesma página", neste artigo.

Para especificar a linguagem de um elemento <SCRIPT>

Não pode misturar VBScript e JScript no mesmo elemento <SCRIPT>. Quem deseja utilizar ambos precisa de ter (pelo menos) dois elementos <SCRIPT> na página.

Tanto o Visual InterDev 1.0 como o Visual InterDev 6.0 incluem ferramentas que geram automaticamente sequências de comandos. No Visual InterDev 1.0, pode utilizar o Script Wizard ("assistente de sequências de comandos") para gerar sequências de comandos. No Visual InterDev 6.0, existem duas ferramentas de geração de sequências de comandos:

As várias ferramentas de geração de sequências de comandos determinam a linguagem a utilizar, com base nas definições efectuadas pelo utilizador. Pode-se alterar, para uma página específica, a linguagem predefinida das ferramentas de sequências de comandos.

Para definir a linguagem do Script Wizard, no Visual InterDev 1.0

Para definir a linguagem a utilizar numa página pelas ferramentas de geração de sequências de comandos, no Visual InterDev 6.0

Também se pode alterar a predefinição para o projecto, para que todas as páginas que se criam já possuam a linguagem predefinida para as ferramentas de geração de sequências de comandos.

Para alterar a linguagem predefinida das ferramentas de geração de sequências de comandos, num projecto do Visual InterDev 6.0

É possível obter mais informações sobre as ferramentas de geração de sequências de comandos do Visual InterDev 6.0, consultando os tópicos "Choosing a Scripting Language" e "Handling Events with HTML Elements", na documentação do Visual InterDev 6.0, no CD da biblioteca da MSDN.

Utilização de ambas as linguagens na mesma página

Espero ter deixado claro, por esta altura, que é possível utilizar ambas as linguagem interpretadas na mesma página. Revisão: porquê fazê-lo? Há duas razões:

Na maior parte dos casos, é possível misturar e combinar numa página ambas as linguagens interpretadas, sem quaisquer problemas. Uma sequência de comandos numa linguagem pode chamar rotinas noutra linguagem, e partilhar variáveis globais com as sequências de comandos noutra linguagem. Existem apenas algumas questões, que por vezes se levantam, como passo a explicar.

Inclusão de parênteses numa chamada em VBScript

Quando se chama uma função de JScript a partir do VBScript, é necessário incluir os parênteses na chamada, ainda que a função não exiga parâmetros. Por exemplo, uma chamada deve ter o seguinte aspecto:

retVal = chamarFunçãoJS()

Quem negligenciar a inclusão de parênteses provoca um valor de retorno inesperado: não é o resultado da função, mas o objecto que contém a própria função!

Ordem de execução das sequências de comandos no servidor

As sequências de comandos entremeadas no servidor são executadas sequencialmente, de cima para baixo. É possível definir rotinas invocáveis (funções ou subrotinas) na sequência de comandos do servidor, para utilização conforme seja necessário.

Todas as sequências de comandos entremeadas devem encontrar-se na mesma linguagem — nomeadamente, a linguagem especificada na directiva @, ao cimo da página. Por isso, não é possível misturar linguagem interpretadas nas sequências de comandos entremeadas.

"Alto lá!", poderá dizer-se. Em teoria, é possível colocar sequências de comandos em elementos <SCRIPT>, tal como se estivessem entremeadas — ou seja, utilizar no elemento comandos que não sejam parte de nenhuma função ou subrotina, como no seguinte exemplo:

<% Response.Write("Alguns comandos entremeados<BR>")%>
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">
    Response.Write("Sequência de comandos num elemento SCRIPT<BR>")
</SCRIPT>

Sim, é possível fazê-lo. Contudo, fica-se à mercê da ordem de execução do processador de ASP do IIS. Por exemplo, ao criar sequências de comandos no servidor e executá-las no IIS 4.0, encontra-se esta ordem de execução:

  1. Sequências de comandos nos elementos <SCRIPT>, nas linguagens não predefinidas.

  2. Sequências de comandos entremeadas.

  3. Sequências de comandos nos elementos <SCRIPT>, na linguagem predefinida.

Como esta ordem aparenta apoiar-se fortemente na sequência de carregamento dos motores de linguagens para ActiveX, e visto que o processador de ASP no IIS pode ser alterado em edições futuras, desencoraja-se vivamente qualquer apoio nesta sequência. Devem-se utilizar os elementos <SCRIPT> apenas para funções ou subrotinas, ou para código cuja sequência de execução não sejam importante. (Há código deste?)

Ordenação de blocos de sequências de comandos

Quando se misturam linguagens, a ordem pela qual os blocos <SCRIPT> aparecem numa página pode influenciar o correcto funcionamento dos mesmos. Considere-se este caso simples, com uma sequência de comandos entremeadas, em VBScript, que chama uma função escrita em JScript:

<SCRIPT LANGUAGE="VBScript">
    ' Chama uma função em JScript
    umNumero = 2
    dobroDoNumero = dobraMe(umNumero)
    document.write("A resposta é " & dobroDoNumero)
</SCRIPT>

<SCRIPT LANGUAGE="JavaScript">
function dobraMe(umNumero){
    return umNumero * 2;
}
</SCRIPT>

Isto não funciona. Mais concretamente, o comando document.write escreve uma cadeia de texto vazia na página. Porquê? Porque no momento em que o bloco de VBScript é processado, o bloco em JScript seguinte, em <SCRIPT>, ainda não foi lido, interpretado nem disponibilizado para a página. Quando o navegador processa os blocos de sequências de comandos da página, fá-lo de cima para baixo.

Neste caso, basta inverter a ordem dos blocos de sequências de comandos para resolver o problema. E, de facto, este tipo de cenário não é de todo incomum — na maior parte dos casos, os blocos <SCRIPT> contêm funções e subrotinas que não são chamadas até que a página tenha sido totalmente carregada, com todos os elementos disponíveis. De qualquer forma, deve-se ter presente que as páginas são processadas linearmente, e que os blocos <SCRIPT> em linguagens diferentes são processados em momentos diferentes.

Distinção entre maiúsculas e minúsculas, e conveções de nomeação

O JScript distingue entre maiúsculas e minúsculas: diz-se sensível à capitularização. Ou seja, é necessário utilizar a combinação correcta de letras maiúsculas e minúsculas, não apenas para todas as palavras-chave do JScript, mas para todos os elementos do espaço de nomes do JScript. Isto inclui todas as palavras-chave em todos os modelos de objectos que se utilizem. Por exemplo, ao utilizar o objecto Response dos ASP, é necessário utilizá-lo exactamente com esta capitularização (por exemplo, Response.Write) ou o JScript, teimosamente, recursar-se-á a acreditar que exista tal coisa. Da mesma forma, para quem escreve uma rotina de tratamento para o evento onclick do DHTML, o JScript não o reconhece no estilo "Onclick", frequente em Visual Basic.

O VBScript, evidentemente, não é sensível à capitularização. Até um certo nível, esta indiferença aplica-se quando se utiliza o VBScript para aceder a elementos escritos em JScript. O seguinte exemplo trivial apresenta duas sequências de comandos. A primeira está escrita em JScript e inclui uma variável global (contador) e uma pequena função inócua (dobraMe). A segunda sequência de comandos está em VBScript e é uma rotina de tratamento de um botão, que chama a função em JScript e apresenta o valor da variável global:

<SCRIPT LANGUAGE=javascript>
var contador;
function dobraMe(umNumero){    // Inicializar o valor do contador global
    if(parseInt(contador)){
        contador = contador + 1;}
    else{
        contador = 1;
    }
    return umNumero * 2;
}
</SCRIPT>

<SCRIPT LANGUAGE="vbscript">
Function bot_onclick()
    numeroADobrar = 12
    alert("O número dobrar = " & DobraMe(numeroADobrar))
    alert("Dobrou o número " & Contador & " vezes.")
End function
</SCRIPT>

Na sequência de comandos em VBScript, optei deliberadamente por não utilizar a capitularização correcta na referência à função dobraMe e na variável contador, mas o exemplo funciona na mesma.

Estas são as boas notícias. As más notícias é que há situações em que é necessário tomar atenção à capitularização:

Se o JScript incluir elementos que se distinguem apenas pela capitularização, o VBScript permite referenciá-los da forma habitual (ou seja, sem distinguir maiúsculas de minúscular). No entanto, o VBScript captura a primeira correspondência, sem olhar à capitularização, e a partir daí só reconhece esse elemento de JScript. Por outras palavas, se o VBScript encontrar em primeiro lugar a função Temporizador(), nunca encontra a variável global chamada temporizador, e vice-versa. Tal verifica-se ainda que se distinga cuidadosamente ambas no código VBScript, porque o VBScript trata os nomes, na prática, como se tivessem todos a mesma capitularização. Infelizmente, não existe verdadeiramente uma forma de contornar isto, excepto (se possível) a alteração do código JScript para que não tire partido desta subtil distinção entre os elementos.

A questão de passagem de nomes de elementos como parâmetros pode não ser comum, salvo em circunstâncias altamente especializadas. Uma dessas circunstâncias é o modelo de objectos de sequências de comandos do Visual InterDev 6.0. Isto é apenas um exemplo, mas à partida esta questão pode surgir em qualquer ocasião em que se empregue idêntica concepção.

O modelo de objectos de sequências de comandos do Visual InterDev 6.0 está escrito inteiramente em JScript. Pode-se escreve código em VBScript para interagir com o modelo de objectos de sequências de comando, utilizando convenções de sensibilidade à capitularização do VBScript. Contudo, por vezes não se chama um método directamente: passa-se o nome de um método a uma função JScript, que se encarrega do chamamento do método.

Um bom exemplo é o método advise, que permite vincular um método a um evento específico. Quando se chama este método, passa-se-lhe o nome de um método, que deve ser chamado quando o evento for despoletado. O código que se segue vincula o evento onmouseover de um botão à rotina de tratamento de eventos changecaption():

<SCRIPT LANGUAGE="VBScript">Function definirMetodosDeAdvise()
    Bot1.advise("onmouseover", "changecaption()")
End Function
</SCRIPT>

Como se estão a passar os nomes para a função JScript como cadeias de caracteres, é necessário utilizar a capitularização correcta. O JScript irá mais tarde avaliar os nomes com as regras internas, que distinguem maiúsculas de minúsculas, pelo que se houver alguma incorrecção, não conseguirá encontrar as funções.

Passagem de matrizes entre VBScript e JScript

Por vezes, uma rotina em VBScript necessita de passar uma matriz como parâmetro ou valor de retorno. Pode-se chamar uma destas rotinas a partir do JScript, mas é necessário converter a matriz em VBScript numa matriz utilizável pelo JScript. Para tanto, deve-se criar um objecto VBArray na função de JScript e convertê-lo para uma matriz JScript utilizando toArray ("para matriz").

Nota   Como o JScript não suporta matrizes multidimensionais, se a matriz original de VBScript for deste tipo é convertida pelo método toArray numa matriz unidimensional de JScript.

O exemplo que se segue inclui uma sequência de comandos em VBScript, para criar uma matriz; e uma sequência de comandos em JScript, que ilustra a forma de obtenção e utilização dessa matriz:

<SCRIPT LANGUAGE="VBSCRIPT">
Function fazerMatrizVB()
    ' Cria uma matriz em VBScript
    dim umaMatriz(1,1)
    umaMatriz(0,0) = "0,0"
    umaMatriz(0,1) = "0,1"
    umaMatriz(1,0) = "1,0"
    umaMatriz(1,1) = "1,1"
    fazerMatrizVB = umaMatriz
End Function

<SCRIPT LANGUAGE="JavaScript">
// Acede a uma matriz de VBScript a partir de uma sequência de comandos em JScript
function obterMatrizVB(){
    var objMatriz;
    var MatrizJS;
    objMatriz = fazerMatrizVB();
    MatrizJS = VBArray(objMatriz).toArray();
    alert("Comprimento da matriz de VBScript = " + MatrizJS.length);
    // Apresenta o conteúdo da matriz
    for(i=1;i<=MatrizJS.length;i++){
       alert(MatrizJS[i-1]);
    }
}
</SCRIPT>

Infelizmente, na edição actual do VBScript (4.0), não é possível efectuar o procedimento inverso: ou seja, não é possível converter uma matriz de JScript numa matriz de VBScript. Caso uma rotina de JScript passe uma matriz, existem as seguintes opções:

Obtenção de actualizações para as linguagens interpretadas

O VBScript e o JScript não são linguagens estáticas. Os motores de ambas são actualizados regularmente, recebendo novas funcionalidades e sendo tratadas (âhm...) algumas anomalias entretanto descobertas. Visto que ambas as linguagens são implementadas como componentes ActiveX, podem ser actualizadas da mesma forma que qualquer outro controlo. Após instalação de um novo motor de linguagem, qualquer aplicação que o chama, como o Internet Explorer ou o Visual InterDev, chama realmente o novo motor, sempre que precisar de executar alguma sequência de comandos.

É possível obter informações acerca da situação dos motores das linguagens, forma de obtenção de actualizações e muitas outras informações sobre programação interpretada sequencial no sítio Web da Microsoft sobre o tema, em http://msdn.microsoft.com/scripting/, que não se deve deixar de visitar. Até lá, apreciem-se as aventuras no mundo da programação interpretada sequencial!

 


Envie comentários sobre este artigo.  Descubra as opções de suporte.

© 2000 Microsoft Corporation. Todos os direitos reservados. Condições de utilização.