Especificação da linguagem DesignScript 2 1

Prévia do material em texto

Página 1
Especificação da linguagem DesignScript 2.1
1. Introductio n
2. Elemento lexical s
2.1 Comentários
2.2 Ponto e vírgula
2.3 Identificadores
2.4 Palavras-chave
2.5 Bool litera l
2.6 Número inteiro l
2.7 Litro de ponto flutuante l
2.8 String litera l
3. Tipos
3.1. Tipo primitivo s
3.2. Tipo definido pelo usuário s
3.3. Coleção s
3.3.1 Lista
3.3.1.1 Classificação
3.3.1.2 Indexação
3.3.1.3 Dinâmica lis t
3.3.1.4 Lista Imutabilidade
3.3.2 Dicionário
3.4. Regra de conversão de tipo s
3.4.1 Caso sem matriz
3.4.2 Promoção de classificação
4. Variáveis
4.1 Dinâmico
4.2 Escopo
4.2.1 Resolução do escopo
5. Funções
5.1 Função declaração n
5.2. Argumentos padrão
5.3 Sobrecargas de função
5.4 Resolução da função
6. Expressões
6.1 Expressão de criação de lista
6.2 Faixa expressio n
6.3. Inline condicional expressio n
6.4 Membro acesso expressio n
6.5 Lista de acesso expressio n
6.6. Operadores
6.6.1 Operadores aritméticos
6.6.2 Operadores de comparação
Página 2
6.6.3 operador lógico s
7. Declarações
7.1 Instruções vazias
7.2 Instruções de importação s
7.3 Declaração de expressão s
7.4 Tarefa s
7,5 Declaração de fluxo s
7.5.1 Declarações de retorno
7.5.2 Declarações de quebra
7.5.3 Declaração Continue
7.6 Se as declarações
7,7 rotações
7.7.1 Enquanto declaração é
7.7.2 Para declaração s
8. Bloco de idiomas s
8.1 Bloco de linguagem associativa padrão k
8.2 Bloco associativo aninhado de linguagem k
8.3. Bloqueio de idioma imperativo
9. Guia de replicação e replicação
9.1 Guia de replicação e replicação
9.2 Regra de despacho de função para replicação e guia de replicação e
10. Lista @ Leve l
11. Funções integradas
12. Internos
12,1 Atualização associativa
12.1.1 Associativity establishmen t
12.1.2 Atualização por reexecução
12.1.3 Dependente s
12.1.4 As entidades que poderia ser dependiam o n
12.1.4.1 Variáveis
12.1.4.2 Função
12.1.4.3 Propriedades
12.1.5 Associativity scop e
12,2 Classe s
12.2.1 Classe DECLARAÇÃO n
12.2.2 Herança
12.2.3 Construtores
12.2.4 Propriedades
12.2.5 Função membro s
12.2.6 Modificador de acesso s
12.2.7 Membros estáticos
12.2.8 Método _Dispose ()
Page 3
1. Introdução
Esta é a documentação para a linguagem de programação DesignScript. O DesignScript é dinâmico,
linguagem associativa e coletada de lixo e fornece forte suporte para uma programação baseada em fluxo
meio Ambiente.
A gramática nesta especificação está na forma Extended Backus-Naur (EBNF). 1
Este documento não contém informações sobre APIs e interface de função externa (Zero Touch
métodos). O último depende da implementação.
2. Elementos lexicais
2.1 Comentários
O DesignScript suporta dois tipos de comentários.
● comentário de uma linha começa com // e parar no final da linha.
● Bloquear comenta começa com / * e termina com * / .
Exemplo:
x = 1; // comentário de linha única
/ *
Bloquear comentários
* /
y = 2;
2.2 Ponto e vírgula
Ponto e vírgula ";" é usado como terminador de uma instrução.
2.3 Identificadores
Identificadores nas variáveis de nome, tipos, funções e espaços de nome do DesignScript.
Identificador =
identifier_start_letter {identifier_part_letter}
"Identifier_start_letter" é o caractere unicode nas seguintes categorias:
● Letra maiúscula (Lu)
● Letra minúscula (Ll)
1 https://en.wikipedia.org/wiki/Extended_Backus-Naur_Form
Page 4
● Letra em titlecase (Lt)
● Letra modificadora (Lm)
● Outra letra (Lo)
● Número da letra (Nl)
"Identifier_part_letter" é o caractere unicode nas categorias de "identifier_start_letter", incluindo
as seguintes categorias:
● Carta combinada (Mn, Mc)
● Letra digital decimal (Nd)
● Letra de conexão (Nc)
● Non-Joiner de largura zero
Marceneiro com largura zero
https://translate.google.com/translate?hl=pt-PT&prev=_t&sl=auto&tl=pt&u=https://en.wikipedia.org/wiki/Extended_Backus%25E2%2580%2593Naur_Form
2.4 Palavras-chave
As seguintes palavras são reservadas como palavras-chave e não podem ser usadas como variáveis definidas pelo usuário.
pausa, classe, construtor, continue, def, else, elseif, estende, for, from, if,
importar, retornar, estático, enquanto,
2.5 Bool literal
O literal booleano pode ser apenas um dos seguintes valores fixos:
verdadeiro falso
2.6 Literal inteiro
O literal inteiro representa uma constante inteira. Está na base decimal.
dígito = '0' .. '9'
hex_digit = '0' .. '9' + 'a' .. 'f' + 'A' .. 'F'
número decimal = dígito {dígito}
Exemplo:
123;
2.7 Literal de ponto flutuante
O literal de ponto flutuante representa uma constante de ponto flutuante na base decimal.
floating_point =
dígito {dígito} '.' [dígito {dígito}] [expoente]
Page 5
| dígito {dígito} expoente
| '.' dígito {dígito} [expoente]
expoente = ('E' | 'e') ['+' | '-'] dígito {dígito}
Exemplo:
1.2e3; // 1200,0;
1,234;
0,123;
2.8 String literal
O literal de string representa uma constante de string. É obtido colocando a sequência de caracteres entre
aspas ( “ ).
Qualquer personagem pode estar na seqüência exceto Citação de nova linha e dupla ( “ ). Caractere barra invertida no
sequência pode ser combinada com o próximo caractere para se tornar um caractere de escape: 2
● \ a
● \ b
● \ f
● \ n
● \ t
● \ v
● \ r
Exemplo:
// "Olá DesignScript
// Língua"
"\" Olá \ tDesignScript \ nIdioma \ "";
3. Tipos
3.1 Tipos primitivos
Tipos primitivos referem-se aos tipos de dados mais básicos disponíveis no idioma. O sistema de tipos em
O DesignScript é dinâmico e orientado a objetos, o que significa que a verificação do tipo de um programa é realizada em
tempo de execução com base nos dados retornados. O DesignScript suporta os seguintes tipos primitivos:
Tipo Faixa de valores * Valor padrão
corda n / D ""
2 https://en.wikipedia.org/wiki/Escape_character
* Estes são detalhes de implementação e não são específicos para a especificação linguagem
Page 6
inteiro -2 63 - 2 63 - 1 0 0
ponto flutuante IEEE 754 de dupla precisão 3 0 0
bool verdadeiro falso falso
nulo nulo nulo
var n / D nulo
Se a implementação do idioma suportar FFI (funções estrangeiras), o valor padrão de todos os outros
Tipos de FFI é 'nulo'.
3.2 Tipos definidos pelo usuário
Tipos definidos pelo usuário são suportados através de mecanismo de classe . Esses tipos, também chamados de classes,
pode conter
● Propriedades
● métodos de instância
● Membros estáticos
Construtores
Somente herança única é permitida no DesignScript.
3.3 Colecções
3.3.1 Lista
Lista = "[" exprList? "]"
exprList = Expressão ("," Expressão) *
Uma lista é um tipo de variável que contém um ou mais valores de um determinado tipo ou uma variedade de tipos. Pode
https://translate.google.com/translate?hl=pt-PT&prev=_t&sl=auto&tl=pt&u=https://en.wikipedia.org/wiki/Escape_character
também conter valores que são listas por si só ou dicionários . Pode ser considerado como uma matriz dinâmica
cujo tamanho não é fixo e é alocado em tempo de execução. As listas são criadas com o operador de colchete ([
]) em torno de um conjunto de valores separados por vírgulas ou deixados em branco para criar uma coleção vazia:
a = []; // lista vazia
a = [1, 2, 3]; // cria uma lista com valores explícitos
Também é possível criar listas usandoExpressões de intervalo.
3 https://en.wikipedia.org/wiki/Double-precision_floating-point_format
Page 7
3.3.1.1 Classificação
Se um tipo tiver colchetes, “[]”, com o sufixo depois dele, ele declarará uma lista. O número de “ [] ” especifica o
classificação ou dimensão da lista. A “ [] .. [] ” especifica de classificação arbitrária, o que significa que a lista pode ser de qualquer
classificação incluindo um valor único ou classificação 0. Por exemplo:
int [] // uma lista inteira cuja classificação é 1
int [] [] // uma lista inteira cuja classificação é 2
int [] .. [] // uma lista inteira com classificação arbitrária
A lista é um tipo único em DesignScript, pois é o único tipo que suporta replicação . Funções podem
replicar sobre argumentos da lista. O nível de um tipo de argumento decide como replicaçãoe replicação
guias trabalhar no argumento durante a função de despacho.
3.3.1.2Indexação
É possível indexar em qualquer local da lista usando o operador de colchete ([]), seguindo as instruções
nome variável. A indexação começa em 0, significando que o primeiro elemento de uma lista 'a' é acessado com: 'a [0]'.
As listas também podem ser usadas como índices para gerar novas sublistas a partir de uma lista. Por exemplo, uma lista contendo
os números [1, 3, 5, 7], quando usados como índice de uma lista, extrairiam o 2º, 4º, 6º e 8º
elementos de uma lista:
// Crie uma nova lista c, de uma coleção de índices
a = 1..10;
b = [1, 3, 5, 7];
c = a [b]; // c = [2, 4, 6, 8]
3.3.1.3 Lista dinâmica
Uma lista no DesignScript é dinâmica. Os membros individuais de uma lista podem ser modificados usando o mesmo índice
operador depois que a lista foi criada. Se definir um valor a um índice que está além do comprimento do
lista, ele será expandido automaticamente e os índices intermediários serão preenchidos com valores "nulos". Isto é também
chamado de "preenchimento nulo". Por exemplo:
x = [1, 2, 3];
x [5] = 4; // x = [1, 2, 3, nulo, nulo, 4];
Também é possível alterar dinamicamente a classificação de uma lista. No exemplo a seguir, 'x' é originalmente uma lista
da classificação 1. Quando é definido como um valor em um índice para uma dimensão que excede o limite / classificação da lista,
os índices intermediários são definidos como valores "nulos" devido ao preenchimento nulo:
Page 8
x = [1, 2, 3];
x [1] [2] = 99; // x = [1, [2, nulo, 99], 3]
Nota: A natureza dinâmica de uma lista não deve ser confundida com a imutabilidade da lista abordada no próximo
seção.
3.3.1.4 Lista Imutabilidade
As listas no DesignScript são imutáveis. Ao copiar uma lista de uma variável para outra variável, é um
operação de cópia profunda, ou seja, todos os elementos da lista também são copiados. O mesmo vale quando
As listas do DesignScript interagem com as listas de C #. A lista original permanece imutável e qualquer operação nela
cria uma nova lista. Exemplo:
a = 1,55;
b = a;
b [7] = 99; // b = [1, 2, 3, 4, 5, nulo, nulo, 99], a = [1, 2, 3, 4, 5]
3.3.2 Dicionário
Dicionário =
"{" KeyValues? "}"
keyValues =
keyValue ("," keyValue) *
keyValue =
string “:” Expressão
Um dicionário DesignScript é um mapa não ordenado de pares de valores-chave, onde as chaves são únicas no dicionário
e só pode ser do tipo 'string'. Os valores no dicionário podem ser de qualquer tipo, incluindo listas e
dicionários por si mesmos. Os dicionários são inicializados usando chaves, '{}'. Aparelhos cacheados vazios criam
um dicionário vazio. Os dicionários podem ser inicializados e consultados usando a seguinte sintaxe:
x = {"foo": 1, "bar": 2, "baz": 3};
a = x ["foo"]; // a = 1
b = x ["baz"]; // b = 3
Ao contrário de Listas, os Dicionários não podem ser modificados dinamicamente depois de inicializados. Eles são estritamente imutáveis.
A replicação não é suportada nos dicionários.
Page 9
3.4 Regras de conversão de tipo
O DesignScript possui certas regras de conversão de tipo incorporadas. Conversão de tipo (também chamada de coerção de tipo)
pode ser explícito ou implícito. O DesignScript não suporta conversão de tipo explícita.
Como o DesignScript é uma linguagem de tipo dinâmico, os valores podem ser convertidos entre diferentes tipos
automaticamente em tempo de execução, conhecido como coerção implícita de tipo. A conversão implícita de tipo pode
acontecem com valores quando eles interagem entre si por meio de operadores como '==' ou acionados pelo
circundante contexto, como com ' if (value) {...} ', onde 'valor' é coagido a boolean. Conversão de tipo
também acontece com argumentos de função quando eles são passados para posições de parâmetro digitadas no
função e são forçados a assumir o tipo do parâmetro. Exemplos:
// Um valor duplo diferente de zero é convertido em um valor verdadeiro quando for coagido para um tipo 'bool'
a = 3,0 == verdadeiro; // a = true
// uma string não vazia se converte em um valor verdadeiro quando for coagida para um tipo 'bool' no
// declaração condicional embutida
i = "olá"? “Não vazio”: “vazio”; // i = "não vazio"
As seguintes regras implícitas de conversão de tipo especificam o resultado da conversão de um objeto de um tipo para aquele
de outro com conteúdo semelhante:
3.4.1 Caso não listado
"Sim" significa conversível, "não" significa não conversível.
Para
De
var int Duplo bool corda usuário definido
var sim Sim se
real
tipo pode
estar
coagido
int
Sim se
tipo real
pode ser
coagido a
Duplo
Sim, se for real
tipo pode ser
coagido a
bool
Sim se
real
tipo pode
estar
coagido
para sequenciar
Sim, se for real
tipo pode ser
coagido a
usuário definido
tipo
int sim sim sim x! = 0 não não
Duplo sim Aviso sim x! = 0 &&
x! = NaN
não não
bool sim não não sim não não
corda sim não não x! = "" sim não
usuário definido sim não não x! = null não Covariant
Page 10
3.4.2 Promoção de classificação
Os argumentos de valor único quando passados para as posições de parâmetro de função com tipos de lista (matriz) são
promovido para listas. Da mesma forma, argumentos de lista com classificação inferior são promovidos para listas com classificação mais alta quando
passado para parâmetros de função com classificação mais alta. As regras de promoção de matriz e coerção de tipos também se aplicam
quando identificadores digitados (variáveis) com tipos de classificação mais alta recebem valores de classificação mais baixa. o
A tabela a seguir mostra todas as regras de promoção de matriz e coerção de tipos no DesignScript:
a: int [] = 123; // a = [123] como o valor atribuído a 'a' é promovido a uma lista
Para
De
var [] int [] Duplo[] bool [] corda[] do utilizador
definiram[]
var sim Sim se
real
tipo pode
estar
coagido
int
Sim se
tipo real
pode ser
coagido a
Duplo
Sim, se for real
tipo pode ser
coagido a
bool
Sim se
real
tipo pode
estar
coagido
para sequenciar
Sim, se for real
tipo de correspondências
usuário definido
tipo
int sim sim sim x! = 0 não não
Duplo sim Aviso sim x! = 0 &&
x! = NaN
não não
bool sim não não sim não não
corda sim não não x! = "" sim não
usuário definido sim não não x! = null não Covariant
4. Variáveis
4.1 Dinâmico
Variáveis no DesignScript são dinâmicas. Se uma variável não for declarada com um tipo, ela poderá ser atribuída gratuitamente
qualquer tipo e o tipo é totalmente dependente do tempo de execução. Exemplo:
a = 123; // a é um 'int'
a = "olá"; // a agora é uma 'string'
No exemplo a seguir, como 'a' é declarado como 'int' e não há conversão de 'string' para 'int', 'a'
é 'nulo' neste caso:
Page 11
a: int = "string"; // a é 'nulo'
4.2 Escopo
O DesignScript usa o escopo do bloco. O escopo de uma variável definida no DesignScript é limitado a um bloco (como4
como um bloco de idiomas) ou uma função em que está definido. Uma variável pode ser usada antes de ser definida porque
de associatividade ea máquina virtual DesignScript irá garantir a propagar a atualização de valor para todos os seus
referências.
x = y; // x = 2, esta instrução será executada após 'y' devido à associatividade
y = 2;
z = x + y; // z = 4, pois será executado após 'x'
No caso de alcance imperativo , os comandos são executados em seqüência ao contrário do código associativo. Tudo
variáveis globais (definidas no escopo externo) usadas no bloco imperativo são copiadas localmente e
quaisquer alterações feitas no bloco imperativo não afetam seus valores no bloco externo. Em outro
palavras, essas variáveis globais são somente leitura (imutáveis) dentro do bloco imperativo:
x = 1;
y = 2;
def foo (x) {
z = 3; // "z" é variável local
retornar x + y; // "x" é parâmetro
// "y" está no escopo externo e não está definido na função interna
}
[Imperativo] {
x = 3; // Uma cópia local de "x" é feita e o global "x" permanece inalterado
m = n; // "m", "n" são variáveis locais.
n = 4; // a ordem das instruções é importante no código imperativo
// como 'm' é atribuído antes de 'n', seu valor permanece 'nulo'
se for verdade) {
y = x + 100; // OK, "x"é visível aqui
}
retornar x + y + m; // é feita uma cópia local de 'y' dentro do bloco imperativo
}
4.2.1 Resolução do escopo
A ordem de pesquisa de um identificador é
● Escopo mais interno.
● Cada escopo externo progressivo, incluindo o escopo da classe.
4 https://en.wikipedia.org/wiki/Scope_(computer_science)#Block_scope
Page 12
● Classes que a classe atual estende.
● O escopo global.
5. Funções
5.1 Declaração de função
FunctionDeclaration =
Identificador “def” [“:” TypeSpecification] ParameterList StatementBlock.
ParameterList =
"(" [Parâmetro {"," Parâmetro}] ")"
Parâmetro =
identificador [“:” TypeSpecification] [DefaultArgument]
StatementBlock =
"{" { Declaração } "}"
O tipo de retorno de uma função é opcional. Por padrão, o tipo de retorno é uma lista classificada arbitrariamente,
“ Var [] .. []” . Se o tipo de retorno for especificado, a conversão de tipo pode acontecer. Não é recomendável especificar
tipo de retorno, a menos que seja necessário.
Uma função deve sempre ser definida no globalbloco linguagem associativa ou bloco nível superior.
Para parâmetros, se seus tipos não são especificados, por padrão, eles são do tipo ' var' . O tipo de
parâmetros devem ser cuidadosamente especificados para quereplicação e guia de replicação funcionará como desejado.
Por exemplo, se o tipo de um parâmetro é var [] .. [] (classificação arbitrária), significa que não há replicação neste
parâmetro.
Exemplo:
def foo: var (x: int [] .. [], y: int = 3)
{
retornar x + y;
}
5.2 Argumentos padrão
A declaração de função permite argumentos padrão para seus parâmetros, mas com uma restrição: all default
argumentos devem ser aplicados aos parâmetros mais à direita.
Exemplo:
Page 13
// é válido porque "y" e "z" são os parâmetros padrão mais à direita
def foo (x, y = 1, z = 2)
{
retornar x + y + z;
}
// é inválido porque "x" não é o parâmetro padrão mais à direita
barra de definição (x = 1, y, z = 2)
{
retornar x + y + z;
}
 
5.3 Sobrecargas de função 
O DesignScript suporta sobrecarga de funções, ou seja, funções com o mesmo nome, mas com diferentes
tipos / número de parâmetros. Qual função será chamada finalmente depende totalmente do tempo de execução,
especialmente sereplicação acontece. A máquina virtual DesignScript tentará descobrir a melhor correspondência baseada
no tipo de argumentos e no tipo de todos os parâmetros de todos os candidatos a funções.
Exemplo:
def foo (x: int, y: int)
{
retornar x + y;
}
def foo (x: duplo, y: duplo)
{
retornar x * y;
}
// chamará foo (x: int, y: int)
r1 = foo (2, 3);
// chamará foo (x: double, y: double)
r2 = foo (2.1, 3.2);
Sobrecargas de função, exceto aquelas com parâmetros que diferem apenas por classificação, são ilegais. este
significa que, para funções sobrecarregadas com o mesmo número e tipos de parâmetros, mas com um
ou mais parâmetros que diferem apenas na classificação, a sobrecarga definida primeiro sempre vence enquanto o restante
são descartados pelo compilador. Por exemplo,
Page 14
def foo (x: número, y: bool)
{
...
}
// sobrecarga inválida, pois apenas as classificações dos parâmetros são diferentes
def foo (x: número [], y: bool [])
{
...
}
// sobrecarga válida
def foo (x: bool, y: número)
{
...
} 
O nó com classificação mais alta pode ser usado em uma chamada replicada e não replicada e, portanto, é
sempre preferiu uma sobrecarga classificada mais baixa. Como regra geral, portanto, os usuários são sempre aconselhados a
elimine sobrecargas de classificação mais baixa em favor de métodos de classificação mais alta, para que o compilador DesignScript sempre
chama o método de classificação mais alta como o primeiro e único que encontrar.
5.4 Resolução da função
A ordem de resolver uma função é:
Escopo mais interno
● Cada escopo externo progressivo
● Escopo da instância de classe
● Classe que a classe estende
● O escopo global
Como as funções podem ser sobrecarregadas, o resultado da resolução da função retornará uma lista de candidatos à função.
A máquina virtual encontrará a melhor correspondência, dependendo do tipo de argumento, dos tipos de
parâmetros eguia de replicação.
Page 15
6. Expressões
6.1 Expressão de criação de lista
ListCreationExpression = “[” [Expressão {“,” Expressão}] “]”
A expressão de criação de lista é criar uma lista. Exemplo:
x = [[1, 2, 3], nulo, [verdadeiro, falso], “DesignScript”];
6.2 Expressão de intervalo
A expressão de intervalo é uma maneira conveniente de gerar uma lista.
RangeExpression =
Expressão [".." ["#"] Expressão [".." ["#"] Expressão]
Existem três formas de expressões de intervalo:
● start_value..end_value
○ Se START_VALUE < END_VALUE , ele gera uma lista em ordem crescente que começa às
START_VALUE , e termina em um valor <= END_VALUE com um incremento de um.
○ Se START_VALUE > END_VALUE , ele gera uma lista em ordem que começa às descendente
START_VALUE e extremidades em um valor> = END_VALUE com um incremento de -1.
● valor_início .. valor_end..incremento
○ Se START_VALUE < END_VALUE , em seguida, o incremento deve ser um valor positivo. Será
gerar uma lista que começa em START_VALUE e último valor <= END_VALUE , incrementando
pelo valor do incremento especificado na expressão de intervalo.
○ Se START_VALUE > END_VALUE , em seguida, o incremento deve ser um valor negativo. Será
gerar uma lista que começa em START_VALUE último valor> = END_VALUE, diminuindo por
o valor do incremento especificado na expressão de intervalo.
● start_value .. # number_of_elements..increment: gera uma lista que contém
number_of_elements elementos. Elemento começa em START_VALUE eo incremento é
incremento . O valor da number_of_elements é sempre arredondado para o número inteiro mais próximo.
● start_value..end_value .. # number_of_elements : gera uma lista que contém
number_of_elements elementos entre igualmente espaçados START_VALUE e END_VALUE
incluindo START_VALUE e END_VALUE . Dependendo se START_VALUE <= END_VALUE , o
A lista gerada será em ordem crescente ou decrescente. O valor da number_of_elements é
sempre arredondado para o número inteiro mais próximo.
Page 16
Exemplo:
1..5; // [1, 2, 3, 4, 5]
5..1; // [5, 4, 3, 2, 1]
1,2 .. 5,1; // [1.2, 2.2, 3.2, 4.2]
5,1 .. 1,2; // [5.1, 4.1, 3.1, 2.1]
1..10..2; // [1, 3, 5, 7, 9]
0..3..0.8; // [0, 0,8, 1,6, 2,4]
10..1 .. 2; // [10, 8, 6, 4, 2]
1 .. # 5..2; // [1, 3, 5, 7, 9]
1..5 .. # 3; // [1, 3, 5]
A expressão de intervalo é manipulada especialmente para seqüências de caracteres com um único caractere. Por exemplo, o seguinte intervalo
expressões também são válidas:
"A" .. "e"; // ["a", "b", "c", "d", "e"]
"A" .. # 4..2; // ["a", "c", "e", "g"]
"A" .. "g" .. # 3; // ["a", "d", "g"]
Se uma expressão de intervalo gerada for necessária para iniciar e terminar precisamente no mínimo e no máximo
valores de expressão de intervalo, podemos aproximar um incremento, chegando o mais próximo possível do
incremento enquanto mantém uma distribuição igual de números entre os limites do intervalo. este
pode ser feito com o sinal de til (~) antes do terceiro parâmetro. 
0..7 ~ 0,75; // [0, 0,777, 1,555, 2,333, 3,111, 3,888, 4,666, 5,444, 6,222, 7]
6.3 Expressão condicional embutida
InlineConditionalExpression = Expressão? Expressão: Expressão;
A primeira expressão na expressão condicional em linha é expressão de condição cujo tipo é bool. Se for
verdadeiro, o valor de "?" cláusula será retornada; caso contrário, o valor da cláusula ":" será retornado. o
tipos de expressões para condições verdadeiras e falsas não são necessários para serem os mesmos. Exemplo:
Page 17
x = 2;
y = (x% 2 == 0)? "Foo": 21;
Expressões condicionais embutidas replicam nas três expressões. Exemplo:
x = [verdadeiro, falso, verdadeiro];
y = ["foo", "bar", "qux"];
z = ["ding", "dang", "dong"];
r = x? y: z; // replica, r = ["foo", "dang", "qux"]
6.4 Expressão de acesso de membro
A expressão de acesso de membro é da forma
xyz
“ Y ” e “ z ” poderia ser, propriedades ou funções membro. Se eles não são acessíveis, nuloserá retornado.
Exemplo:
p = Circle.ByCenterPointRadius (Point.ByCoordinates (5, 0, 0), 10);
x = p.CenterPoint.X; // expressão de acesso do membro, x = 5
6.5 Expressão de acesso à lista
A expressão de acesso à lista tem o formato
machado]
“ X ” poderia ser valor inteiro ou uma chave de qualquer tipo de tipos (se “ um ” é um dicionário ).
As seguintes regras se aplicam:
● Se for apenas recebendo o valor, se “ um ” não é uma lista, ou o comprimento de “a” é menor que “ x ”, ou a patente de “ um ”
é menor do que o número de índices de, por exemplo, a patente de “ um ” é 2, mas a expressão é
um [x] [y] [z] , haverá um aviso “IndexOutOfRange” e nulo irá ser devolvido.
● Se estiver atribuindo um valor à lista, se “ um ” não é uma lista, ou o comprimento de “a” é menor que “ x ”, ou o
posto de “ um ” é menor do que o número de índices, “ a ” será estendido ou a sua dimensão será
promovido para poder acomodar o valor. Por exemplo,
a = 1;
a [1] = 2; // "a" será promovido, a = [1, 2] agora
Page 18
a [3] = 3; // "a" será estendido, a = [1, 2, nulo, 3] agora
a [0] [1] = 3; // "a" será promovido, a = [[1, 3], 2, null, 3] agora
6.6 Operadores
Os seguintes operadores são suportados no DesignScript:
+ Adição aritmética
- Subtração aritmética
* Multiplicação aritmética
/ Divisão aritmética
% Modificação aritmética
> Comparação grande
> = Comparação maior que
< Comparação menos
<= Comparação menor que
== Comparação igual
! = Comparação não igual
&& Lógico e
|| Lógico ou
! Lógico não
- Negar
Todos os operadores suportam replicação. Exceto operador unário “!”, Todos os outros operadores também suportam replicação
guia. Ou seja, os operandos podem ser anexados aos guias de replicação.
x = [1, 2, 3];
y = [4, 5, 6];
r1 = x + y; // replicação
// r1 = [5, 7, 9]
r2 = x <1> + y <2>; // guia de replicação
// r2 = [
// [5, 6, 7],
// [6, 7, 8],
// [7, 8, 9]
//]
Operador precedente
Precedência Operador
6 -
5 *, /,%
4 +, -
Page 19
3 >,> =, <, <=, ==,! =
2 &&
1 ||
6.6.1 Operadores aritméticos
+, -, *, /,%
Normalmente, os operandos são valor inteiro ou valor de ponto flutuante. "+" Pode ser usado como string
concatenação:
s1 = "design";
s2 = "Script";
s = s1 + s2; // "DesignScript"
6.6.2 Operadores de comparação
As instruções que usam esses operadores resultam em um valor "verdadeiro" ou "falso".
>,> =, <, <=, ==,! =
6.6.3 Operadores lógicos
Toda declaração que usa um operador lógico pode retornar apenas um valor "verdadeiro" ou "falso".
&&, ||,!
O operando deve ser do tipo "bool"; caso contrário, ocorrerá conversão de tipo.
7. Declarações
7.1 Instruções vazias
A declaração vazia é
;
7.2 Instruções de importação
As instruções Import import importam outro arquivo de origem DesignScript ou assembly C # para o namespace atual.
ImportStatement = “import” “(” (string | (ident from string)) “)”
Page 20
Se importar uma montagem C #, a máquina virtual DesignScript gerará classes DesignScript para classes
definido na montagem, isso é feito pela FFI.
As instruções de importação podem importar todas as entidades encontradas no local ou para uma entidade nomeada específica encontrada
no local.
A localização pode ser especificada por:
● Um caminho de arquivo relativo, usando convenções locais do sistema operacional.
● Um caminho de arquivo absoluto, usando convenções locais do sistema operacional.
● um URI.
Exemplo:
import ("/home/dev/libraries/foo.ds");
import (ponto de "Geometry.dll");
Observe que as instruções de importação podem ser usadas apenas em arquivos DesignScript (com uma extensão ".DS"), que pode
ser importado para o Dynamo. As instruções de importação não podem ser usadas em nós de bloco de código no Dynamo.
7.3 Instruções de expressão
ExpressionStatement = Expressão “;”
Instruções de expressão são expressões sem atribuição.
7.4 atribuições
Atribuição = Expressão “=” ((Expressão “;”) | LanguageBlock)
O lado esquerdo de "=" deve ser atribuído. Tipicamente, é expressão acesso membro ou acesso à matriz
expressão ou variável. Se o lado esquerdo for uma variável que não foi definida anteriormente, o
declaração de atribuição definirá essa variável.
7.5 Instruções de fluxo
As instruções de fluxo alteram o fluxo de execução do programa. Uma declaração de fluxo é uma das seguintes:
1. Um retornodeclaração.
2. A quebra de declaração no bloco de para ou enquanto declaração embloco imperativo de linguagem.
3. Um continuardeclaração no bloco de para ouenquantodeclaração no bloco linguagem imperativa.
7.5.1 Declarações de retorno
Page 21
ReturnStatement = "return" Expressão ";"
Uma instrução "return" finaliza a execução da função mais interna e retorna ao seu chamador, ou
termina o mais íntimo bloco linguagem imperativae retorna ao bloco de idioma de nível superior ou
função.
7.5.2 Instruções de quebra
BreakStatement = "break" ";"
A declaração “break” termina a execução do mais íntimo “ para”Loop ou“ enquanto" ciclo.
Exemplo:
i = [imperativo]
{
a = 0;
while (true) // isso fará com que o loop while seja executado indefinidamente
{
a = a + 1;
se (a == 10)
pausa; // quando 10 é igual a, essa instrução interrompe o loop
}
retornar a; // a = 10
};
i = [imperativo]
{
a = 0;
l = 1 100;
para (i em l)
{
a = i;
se (a == 15)
pausa;
}
retornar a; // a = 15 e não 100
};
7.5.3 Continuar declaração
ContinueStatement = "continue" ";"
Exemplo:
i = [imperativo]
Page 22
{
a = 0;
1 = 10;
para (i em l)
{
if (i% 2! = 0) // pula todos os números ímpares
Continuar; // continua a próxima iteração do loop, pula o corpo restante
a = a + i;
}
retornar a; // a = 30, soma de todos os números pares até 10
};
A declaração “continuar” começa a próxima iteração do mais íntimo “ para”Loop ou‘ enquanto que ’loop.
7.6 Se as declarações
As instruções "if" especificam a execução condicional de várias ramificações com base no valor booleano de
cada expressão condicional. “Se” declarações são válidas somente no bloco de linguagem imperativa .
IfStatement =
"If" "(" Expression ")" StatementBlock
{"Elseif" "(" Expression ")" StatementBlock}
["Else" StatementBlock]
Exemplo:
x = 5;
if (x> 10) {
y = 1;
}
elseif (x> 5) {
y = 2;
}
elseif (x> 0) {
y = 3;
}
outro {
y = 4;
}
7.7 rotações
No código Imperative DesignScript, um programador tem a opção de escrever código que itera manualmente
a lista, extraindo elementos individuais da coleção, um de cada vez. Loops são construções de linguagem para
repita a execução sobre um bloco de código. O número de vezes que um loop é chamado pode ser governado pelo
comprimento da lista (loop "for") em que o loop é chamado com cada elemento da lista como entrada. O número
As iterações de um loop também podem ser determinadas por uma expressão booleana (“while loop”), onde o loop é
chamado até que a expressão booleana retorne false. Os loops podem ser usados para gerar coleções, procurar um
solução ou chame repetidamente um determinado bloco de código.
Page 23
7.7.1 Declarações while
As instruções "while" executam repetidamente um bloco em um loop até que a condição se torne falsa. "enquanto"
declarações são válidas somente no bloco de linguagem imperativa. Um enquanto loop pode ser executado em infinitamente se a condição
não avalia a falsa por isso é importante ter uma condição de terminação para sair do loop
a menos que haja uma explícita pausadeclaração dentro do laço que a execução forças para sair da enquanto
ciclo.
WhileStatement = "while" "(" Expression ")" StatementBlock
Exemplo:
soma = 0;
x = 0;
enquanto (x <10)
{
soma = soma + x;
x = x + 1;
}
// soma == 55
7.7.2 Para declarações
"For" itera todos os valores na cláusula "in" e atribui o valor à variável de loop. A expressão em "in"
cláusula deve retornar uma lista; se for um singleton, é uma avaliação de declaração única. Declarações "for" são
válido apenas embloco imperativo de linguagem. Assim como enquanto declarações, pode-se sair de um para loop usando
aquebrar declaração no corpo daparadeclaração.
ForStatement = “for” “(” Identifier “in” Expression “)” StatementBlock
Exemplo:soma = 0;
para (x em 1..10)
{
soma = soma + x;
}
// soma == 55
8. Blocos de Idiomas
O DesignScript possui dois paradigmas de linguagem - Associativo e Imperativo. Esses idiomas são cada um
escritos em seus próprios blocos de idiomas.
Page 24
8.1 Bloco de idioma associativo padrão
Por padrão, todas as declarações estão em um nível mais alto padrão de bloco linguagem associativa, Então atualização associativa é
ativado por padrão.
Diferentemente de um bloco de idioma aninhado, não há declaração de retorno no bloco de idioma associativo de nível superior.
8.2 Bloco de linguagem associativa aninhada
É válido definir explicitamente um bloco de idioma aninhado, associativo ou imperativo, no padrão
bloco associativo de linguagem ou em uma função. Também é válido definir um bloco de idioma imperativo aninhado
dentro de um bloco de linguagem associativa aninhada e vice-versa.
AssociativeLanguageBlock = "[" "Associativo" "]" StatementBlock
As instruções no bloco de idioma associativo padrão são executadas na ordem em que as instruções
dependem um do outro. Isso significa que todas as dependências de uma instrução são executadas antes do
própria declaração, independentemente da ordem em que as declarações ocorrem no bloco associativo.
As instruções em um bloco associativo aninhado são executadas sequencialmente até uminstrução de retorno retorna um valor;
caso contrário, os blocos linguagem retorna nulo .
É inválido definir um bloco de idioma aninhado dentro de um bloco aninhado do mesmo tipo.
Exemplos:
x = 1;
// z = 3
z = [associativo]
{
y = 2;
retornar x + y;
}
[Associativo]
{
// bloco de idioma associativo inválido
[Associativo]
{
}
}
8.3 Bloqueio de idioma imperativo
O bloco de idioma imperativo fornece uma maneira conveniente de usar a semântica imperativa. Semelhante ao aninhado
bloco de idioma associativo, o bloco de idioma imperativo executa todas as instruções sequencialmente, a menos que um
declaração é uma declaração de retorno para retornar um valor. Um bloco de idioma imperativo só pode ser definido em
um bloco de idioma associativo externo ou o bloco de idioma associativo padrão.
Page 25
As principais diferenças entre o bloco associativo de linguagem e o bloco imperativo de linguagem são:
● atualização associativa está desabilitado no bloco linguagem imperativa.
● As declarações "if", "for" e "while" estão disponíveis apenas em blocos de idiomas imperativos.
Exemplo:
x = 1;
// define um bloco de idioma imperativo no bloco de idioma associativo superior
y = [imperativo]
{
if (x> 10) {retorno 3;
}
caso contrário, se (x> 5) {
retorno 2;
}
outro {
retornar 1;
}
}
soma def (x)
{
// define um bloco de linguagem imperativo dentro de uma função, que está em um global
// bloco de linguagem associativo
voltar [Imperativo]
{
s = 0;
para (i em 1..x)
{
s = s + i;
}
retorno s;
}
}
[Associativo]
{
// define um bloco de linguagem imperativo dentro de um bloco de linguagem associativo
voltar [Imperativo]
{
retorno 42;
}
}
[Imperativo]
{
// bloco de idioma imperativo inválido
[Imperativo]
{
Page 26
}
}
9. Guia de replicação e replicação
9.1 Guia de replicação e replicação
A replicação é uma maneira de expressar a iteração no bloco de linguagem associativo. Aplica-se a uma chamada de função quando
a classificação dos argumentos de entrada excede a classificação dos parâmetros. Em outras palavras, uma função pode ser chamada
várias vezes na replicação, e o valor de retorno de cada chamada de função será agregado e
retornado como uma lista.
Existem dois tipos de replicação:
● Replicação zip: para várias listas de entradas, a replicação zip consiste em pegar todos os elementos de cada
listar na mesma posição e chamar a função; o valor de retorno de cada chamada de função é
agregado e retornado como uma lista. Por exemplo, para argumentos de entrada x = [x1, x2, ..., xn]
e y = [y1, y2, ..., yn] , ao chamar a função f (x, y) com a replicação do fecho de correr, é
equivalente a [f (x1, y1), f (x2, y2), ..., f (xn, yn)] . Como os comprimentos dos argumentos de entrada
poderia ser diferente, a replicação zip poderia ser:
○ Menor replicação zip: use o tamanho menor
○ Replicação zip mais longa: use o comprimento mais longo, o último elemento na lista curta de entradas
será repetido
A replicação zip padrão é a replicação zip mais curta; caso contrário, precisa usar o guia de replicação
para especificar a abordagem mais longa.
● Replicação cartesiana: é equivalente a loop aninhado em linguagem imperativa. Por exemplo, para
argumentos de entrada x = [x1, x2, ..., xn] e = y [y1, y2, ..., yn] , ao chamar
função f (x, y) com a replicação cartesiano e os índices são cartesianas [0, 1] , o que significa
a iteração sobre o primeiro argumento é o primeiro loop e a iteração sobre o segundo
argumento é o loop aninhado; é equivalente a [f (x1, y1), f (x1, y2), ..., f (x1, yn),
f (x2, y1), f (x2, y2), ..., f (x2, yn), ..., f (xn, y1), f (xn, y2), ..., f (xn ,
yn)] .
O guia de replicação é usado para especificar a ordem dos índices de replicação cartesiana; o guia de replicação inferior,
o loop externo. Se duas guias de replicação tiverem o mesmo valor, a replicação zip será aplicada.
ReplicationGuide = "<" número ["L"] ">" {"<" número ["L"] ">"}
Somente o valor inteiro é permitido no guia de replicação. Postfix “L” denota se a replicação é zip replicação,
use a estratégia de replicação zip mais longa. O número de guia de replicação especifica o nível aninhado.
Por exemplo, o guia de replicação xs <1> <2> indica o argumento deve ser, pelo menos, de duas dimensões
e seu nível aninhado é 2; também pode ser expresso pelo seguinte pseudo-código:
Page 27
// xs <1> <2>
para (ys em xs)
{
para (y em ys)
{
...
}
}
Exemplo:
def add (x: var, y: var)
{
retornar x + y;
}
xs = [1, 2];
ys = [3, 4];
zs = [5, 6, 7];
// usa replicação zip
r1 = adicionar (xs, ys); // r1 = [4, 6]
// use a menor replicação zip
r2 = adicionar (xs, zs); // r2 = [6, 8];
// a replicação zip mais longa deve ser especificada através do guia de replicação.
// os guias de aplicação devem ter o mesmo valor; caso contrário cartesiano
// replicação será aplicada
r3 = adicionar (xs <1L>, zs <1L>); // r3 = [6, 8, 9]
// usa replicação cartesiana
r4 = adicionar (xs <1>, ys <2>); // r4 = [[4, 5], [5, 6]];
// usa replicação cartesiana
r5 = adicionar (xs <2>, ys <1>); // r5 = [[4, 5], [5, 6]];
Além da replicação para chamada de função explícita, o guia de replicação e replicação também pode ser aplicado ao
seguintes expressões:
1. Operadores binários como +, -, *, / e assim por diante. Todos os operadores binários no DesignScript podem ser vistos como um
função que aceita dois parâmetros, e o operador unário pode ser visto como uma função que
aceita um parâmetro. Portanto, a replicação serão aplicados a expressão “ xs + ys ” se “ xs ” e
“ Ys ” são listas.
2. Intervalo de expressão.
3. expressão condicional em linha na forma de “ xs? ys: zs ”onde‘ xs ’,‘ ys ’e‘ zs ’são listas.
4. Indexação de matrizes. Por exemplo, xs [ys] onde ys é uma lista. A replicação pode se aplicar à matriz
indexação nos dois lados da expressão de atribuição. A replicação de nota não se aplica a vários
índices.
Page 28
5. Expressão de acesso de membro. Por exemplo, xs.foo (ys) , onde xs e ys são listas. Replicação
Esse guia pode ser aplicado a objetos e argumentos. Se xs é uma lista, xs deve ser uma lista homogênea,
ou seja, todos os elementos em XS são do mesmo tipo.
9.2 Regra de despacho de função para replicação e guia de replicação
O uso da replicação zip ou replicação cartesiana depende totalmente do guia de replicação especificado, dos tipos
de argumentos de entrada e os tipos de parâmetros. Como o argumento de entrada pode ser um método heterogêneo
Na lista, a implementação calculará qual combinação de replicação gerará o tipo mais curto
distância de conversão.
Observe que se o argumento estiver na lista irregular, o resultado da replicação será indefinido.
Formalmente, para uma “função f (x1: t1, x2: t2, ..., xn: TN) ” e de entradaargumentos “ a1, a2, ...,
uma regra de despacho de função é:
1. Obter uma lista de sobrecarregada função f () com o mesmo número de parâmetros. Essas funções são
candidatos.
2. Se houver guias de replicação, eles serão processados nível por nível. Por exemplo, para função
chamada f (como <1> <1>, bs, cs <1> <2>, ds <2> <1L>) , existem dois níveis de guias de replicação.
uma. Para cada nível, classifique as guias de replicação em ordem crescente. Se o guia de replicação for menor que
ou igual a 0, este guia de replicação será ignorado (é um guia de replicação de stub).
Eu. Para cada guia de replicação, se aparecer em vários argumentos, replicação zip
aplica-se. Por padrão, usando o laço mais curto. Se algum número de guia de replicação tiver
sufixo “L”, o laço mais longo se aplica.
ii. Caso contrário, a replicação cartesiana se aplica.
iii. Repita a etapa b até que todas as guias de replicação tenham sido processadas.
b. Repita a etapa a até que todos os níveis de replicação tenham sido processados.
c. Neste exemplo, as seguintes replicações serão geradas:
Eu. Fecho de correr de replicação em como , cs
ii. Replicação cartesiano em ds
Page 29
iii. Fecho de correr de replicação em como , ds
iv. Replicação cartesiano em ds
3. Após o tratamento de guia de replicação, o posto de cada argumento de entrada é computado: R1 =
rank (a1), r2 = rank (a2), ..., rn = rank (an); para cada categoria, atualizá-lo para r = r -
<número do guia de replicação no argumento>. A lista final [R1, R2, ..., rn] é chamado de
lista redução , cada valor representa uma redução possível loop aninhado no máximo
argumento correspondente.
4. Com base nessa lista de redução, calcule uma combinação de listas de redução cujos valores de elemento são
menor ou igual ao valor de redução correspondente na lista de redução de base. Para cada
lista de redução [R1, R2, ..., rn] , de forma iterativa fazer o seguinte cálculo para gerar
replicações:
uma. Para qualquer ri > 0, ri = ri - 1. Se existirem várias reduções cujos valores são maiores
igual ou igual a 1, a replicação zip se aplica; caso contrário, a replicação cartesiana se aplica.
5. Combine as replicações geradas nas etapas 3 e 4, com base nos argumentos de entrada e no
assinatura das funções candidatas, escolha a melhor função correspondente e a melhor replicação
estratégia. Durante o processo, se o tipo de parâmetro e o tipo de argumento forem diferentes,
a pontuação da distância do tipo será calculada.
10. Lista @ Nível
List @ Level é um recurso de lista especial que retorna uma lista nivelada em um nível especificado. Se uma entrada for especificada
como uma lista dominante, a estrutura da produção será a mesma da estrutura da lista dominante.
Por exemplo, para duas entradas xs (graduação 4 lista) e ys (graduação 3 lista), queremos chamar a função f () com o
segundo nível de xs e ys , onde xs é a lista dominante: + (xs @@ L2, ys @ L2) . A saída preserva a lista
Estrutura do xs como é a lista dominante (representado pelo símbolo '@' double):
xs = [[[[a "," b "], [" c "," d "]], [[" e "," f "], [" g "," h "]]], [ [["eu j"]]]];
ys = [[["1", "2"], ["3", "4"], ["5", "6"]], [["7", "8"], ["9" , "10"], ["11", "12"]]];
x = xs @@ L2 + ys @ L2;
Page 30
xs ys
ys @ L2 retorna:
Page 31
[
[1, 2]
[3, 4]
[5, 6]
[7, 8]
[9, 10]
[11, 12]
]
xs @ L2 retorna:
O que outras pessoas estão dizendo
[
[a, b]
[c, d]
[e, f]
[g, h]
[eu j]
]
Page 32
x = xs @@ L2 + ys @ L2 retorna:
11. Funções integradas
As seguintes funções são funções globais internas nativas do DesignScript e usadas
internamente na VM. Eles não são expostos na interface do Dynamo, mas ainda podem ser invocados no bloco de código
nós:
● Concat: var [] .. [] (lista1: var [] .. [], lista2: var [] .. [])
Concats list1 e list2 e retorna uma nova lista.
● Contagem: int (lista: var [] .. [])
Retorna o número de elementos na lista especificada.
● Avaliar: var [] .. [] (fptr: fptr, parâmetros: var [] .. [], descompacte: bool)
Avalia um ponteiro de função com parâmetros especificados.
● Suspensão (x: int)
Coloque a máquina virtual em suspensão por x milissegundos.
● Transposição: var [] .. [] (lista: var [] .. [])
Troca linhas e colunas em uma lista de listas. Se houver algumas linhas mais curtas que outras,
valores nulos são inseridos como espaços reservados na lista de resultados, para que seja sempre retangular.
● __GC ()
Forçar coleta de lixo.
As seguintes funções internas são expostas ao usuário final como herdadas da classe FFI List:
● Igual a: bool (objeto A: var, objeto B: var)
Determina se duas instâncias de objeto são iguais.
● GroupByFunction (lista: var [] .. [], func: Function)
Agrupa itens em uma lista conforme determinado por uma função predicada.
Page 33
● MaximumItemByKey (lista: var [] .. [], keyProjetor: Função)
Determina o item máximo em uma lista que satisfaz uma função de predicado.
● MinimumItemByKey (lista: var [] .. [], keyProjetor: Função)
Determina o item mínimo em uma lista que satisfaz uma função de predicado.
● Classificação (lista: var [] .. [])
Conta a classificação máxima da lista especificada.
● RemoveIfNot: var [] .. [] (lista: var [] .. [], tipo: string)
Remove os membros da lista que não são membros do tipo especificado.
● SortByFunction (lista: var [] .. [], func: Function)
Classifica itens em uma lista de acordo com uma determinada função.
● TrueForAll: bool (lista: var [] .. [], predicado: Function)
Retorna true se o predicado especificado for satisfeito para todos os itens da lista.
● TrueForAny: bool (lista: var [] .. [], predicado: Function)
Retorna true se o predicado especificado for satisfeito para qualquer um dos itens da lista.
12. Internos
12.1 Atualização associativa
Observe que a atualização associativa está desabilitada nos nós do bloco de código, impedindo a redefinição de variável
no entanto, a própria linguagem suporta isso. A atualização associativa pode ser vista em ação escrevendo DesignScript
arquivos e executá-los.
Associatividade é um recurso do DesignScript que permite a propagação de uma mudança de variável para todos
declarações dependentes no programa. A propagação da mudança acontece no tempo de execução e é tratada pelo
o mecanismo de atualização da máquina virtual DesignScript.
Exemplo de atualização associativa:
1: x = 1;
2: y = x;
3: x = 3;
Se o código é em bloco linguagem associativa , ele será executado como segue:
1. “ x ” é definido como 1.
2. “ y ” é definida como “X” e depende de “ x ”, então “ y ” é 1.
3. “ x ” é alterado para 3. Como “ y ” depende de “ x ”, “ y ” será atualizado para 3.
Na linha 2, “ y ” depende de “ x ” ou “ y ” é um dependente de “ x ”; em seguida, na linha 3, a mudança de “ x ” irá atualizar
“ Y ” por meio de re-executar o comando de atribuição correspondente que estabelece associatividade.
Por outro lado, se o código estiver embloco imperativo de linguagem, A mudança de “ x ” não irá atualizar “ y ”, apenas
como outras linguagens de programação.
Existem quatro elementos principais na definição e atualização de associatividade:
Page 34
1. O estabelecimento da associatividade é feito por declaração de atribuição.
2. A atualização é feita reexecutando a instrução de atribuição.
3. O dependente (no lado esquerdo da tarefa) pode ser
● Variáveis
● Propriedades
4. As entidades que podem ser dependentes são
● Variáveis
● Propriedades
● Funções
12.1.1 Estabelecimento de associatividade
A declaração de atribuição no bloco de idioma associativo estabelece um relacionamento entre o
entidades e as entidades usadas na instrução para calculá-lo. A redefinição removerá a anterior
associatividade (se houver) e redefinir associatividade.
É importante observar que as entidades atribuídas e as entidades das quais dependem devem ser
definido no mesmo escopo. Veja âmbito associatividade .
Um exemplo no bloco de linguagem associativo
1: x = 1;
2: y = 2;
3: z = foo (x, y);
4: x = 3;
5: y = 4;
6: z = 0;
7: x = 5;
Na linha 3, a atribuição estabelece o associativity entre “ z ” e “ foo ”, “ x ” e “y” , de modo “ z” vontade
dependem “ foo ”, “ x ” e “ y ”. Depois de actualização “ x ” a 3, linha 3 será a actualização de “executado re- z ”; depois de
actualizando “ y ” para a linha 4 5, a linha 3 será novamente executado-re.
Na linha 6, a redefinição de “ z remover” previamente estabelecido associativity. Agora “ z ” não depende mais
em outras entidades, de modo a seguinte atualização do “ x ” na linha 7 não irá incorrer em re-cálculo de “ z ”.
A declaração de atribuição no bloco de idioma imperativo altera apenas variáveis / propriedades às quais são atribuídos
para e não possui atualização implícita.
Um exemplo no bloco de idioma imperativo
[Imperativo]
{
Page 35
1: x = 1;
2: y = x;
3: x = 3;
}
O código é executado linha por linha, nenhuma recálculo ocorrerá no bloco imperativo da linguagem. Depois de
execução, “ x ” é 3 e “ y ” é 1.
12.1.2 Atualização por reexecução
A alteração é propagada a todos os dependentes recursivamente, reexecutando todas as instruções que estabelecem
associatividade.
12.1.3 Dependentes
Um dependente pode ser uma variável ou uma propriedade. O código abaixo mostra o último caso:
classe Foo
{
x;
}
f = Foo ();
m = 21;
// a propriedade "x" depende de "m"
fx = m;
m = 42;
r = fx; // r é 42
Depois de “ m ” é atualizado para 42, instrução de atribuição “ fx = m ” será re-executado à propriedade update “ x ”.
12.1.4 Entidades que poderiam depender
12.1.4.1 Variáveis
A alteração da variável acionará atualizações de seus dependentes. A variável pode aparecer em:
Expressão
● Parâmetros: sob a forma de “ x = f (y, z) ”, em que “x” depende “ f () ” e variáveis “ y ” e
"Z".
● indexação Lista: sob a forma de “ X = Y [Z] ”, em que “ x ” depende de duas variáveis “ y ” e matriz
indexador variável “ z ”.
Há um caso especial de auto-redefinição, ou seja, uma variável depende de si mesma. Por exemplo, “ a = a + 1 ”.
Esse tipo de auto-redefinição não removerá a associação previamente estabelecida entre "a" e outras
variáveis. Além disso, a mudança de “ uma ” só irá atualizar seus dependentes, e não “ um ” em si. Exemplo a seguir
ilustra este caso:
Page 36
1: x = 1;
2: y = 2;
3: x = x + y;
4: z = x + y;
5: x = x + 1;
O código acima será executado da seguinte maneira:
1. “ x ” é definido como 1.
2. “ y ” é definido como 2.
3. “ x ” é mudado para “ x + y ”. Assim, “ x ” depende de “ y ”, “ x ” é 3 agora.
4. “ z ” é ajustado para “ x + y ”. Assim, “ z ” depende de “ x ” e “ y ”, “ z ” é de 5 agora.
5. “ x ” é aumentado em 1. A atualização para o “ z ” será acionado, “ z ” é 6 agora.
Também é bom que aparece variáveis na lista de parâmetros da função, assim como o exemplo na associatividade
estabelecimento shows.
12.1.4.2 Função
Na forma de:
x = f (...);
O estabelece atribuição associatividade entre o “ x ” e função “ f () ”. Qualquer atualização do corpo da função
de qualquer “sobrecarregado f () ” fará com que o re-execução desta instrução. Observe que este recurso está disponível apenas
quando o live runner está ativado (disponível apenas no ambiente de programação visual).
12.1.4.3 Propriedades
Na forma de:
r = xyz;
A atribuição estabelece associativity entre “ r ” e variável “ X ” e propriedades de “ y ” e “ z ”. Qualquer
actualização para “ x ”, “ y ” e “ z ” irá actualizar “ r ”.
Exemplo:
classe Foo
{
x;
construtor Foo (_x)
{
x = _x;
}
}
Page 37
classe Bar
{
foo;
barra do construtor (_x)
{
foo = Foo (_x);
}
}
b = barra (0);
t = b.foo.x;
b.foo.x = 1; // atualiza "x"
b.foo = Foo (2); // atualize "foo"
b = barra (3); // atualize "b"
Cada atualização nos últimos três declaração vai declaração re-executar “ t = b.foo.x ” para atualizar o valor de
“ T ”.
12.1.5 Escopo de associatividade
Como o estabelecimento de associatividade e atualização são ambos em tempo de execução, é importante observar que o
estabelecimento e atualização de associatividade devem aplicar-se apenas a entidades no mesmo escopo; caso contrário, o
O resultado é indefinido. Se já houver uma associatividade, a associatividade pode ser removida.
Existem quatro casos indefinidos:
1. O dependente é definido no escopo superior e depende de variáveis definidas no mesmo escopo,
mas a associatividade é estabelecida em função. Por exemplo, no código abaixo, “ x ” e “ y ” ambos definidos
no bloco de linguagem associativa global. A execução de “foo ()” executará a linha 5 para estabelecer
associativity entre “ x ” e “ y ”. O comportamento esperado desse tipo de associatividade é
indefinida, portanto atualizar “ y ” a 3 não será necessariamente atualizar “ x ” como o DesignScript virtual
máquina não suporta apenas executar a linha 5 sem executar a função todo “ foo () ”.
1: x = 1;
2: y = 2;
3: def foo ()
4: {
5: x = y;
6: retornar nulo;
7:}
8:
9: foo ();
10: y = 3; // a atualização para "x" é indefinida
2. O dependente é definido no escopo superior e depende das variáveis definidas no mesmo escopo,
mas a associatividade é estabelecida no bloco de idiomas aninhados. Por exemplo, no código abaixo, “ x ” e
Page 38
“ Y ” ambos definidos no bloco linguagem associativa global. A execução do imperativo aninhadolinguagem irá estabelecer associatividade entre o “ x ” e “ y ” na linha 5, mas o comportamento esperado de
esse tipo de associatividade também é indefinido.
1: x = 1;
2: y = 2;
3: [Imperativo]
4: {
5: x = y;
6: retornar nulo;
7:}
8: y = 3; // a atualização para "x" é indefinida
3. O dependente é definido no escopo superior, mas depende das variáveis definidas na função. Para
exemplo, “ x ” depende da variável local “ y ” em “ foo () ”.
1: x = 1;
2: def foo ()
3: {
4: y = 2;
5: x = y;
6: retornar nulo;
7:}
8: foo ();
9: y = 3;
4. O dependente é definido no escopo superior, mas depende das variáveis definidas na linguagem aninhada
quadra. Por exemplo, “ x ” depende variável “local y ” no bloco linguagem imperativa aninhada.
1: x = 1;
2: [Imperativo]
3: {
4: y = 2;
5: x = y;
6: retornar nulo;
7:}
12.2 Aulas
Nota: As classes podem ser declaradas apenas nos arquivos de script DesignScript ou nos arquivos com extensão .DS. Classe
declarações não são permitidas em nós de bloco de código no Dynamo. Os arquivos do DS podem ser importados para um Dynamo
sessão a ser consumida como nós.
Page 39
12.2.1 Declaração de classe 
ClassDeclaration =
Identificador de "classe" [identificador "estende"]
“{“ [ClassMemberDeclaration] “}”
ClasMemberDeclaration =
ConstructorDeclaration
| MemberDeclaration
ConstructorDeclaration =
Identificador "construtor" ParameterList
[":" "Base" "(" ArgumentList ")"]
StatementBlock
MemberDeclaration =
[AccessModifier] [estático] (FunctionDeclaration | VariableDeclaration “;”)
AccessMmodifier = "public" | "Protegido" | "privado"
A classe só pode ser definida no nível superior bloco linguagem associativa.
12.2.2 Herança 
O DesignScript suporta apenas herança única. Ou seja, apenas uma classe base é permitida.
Exemplo:
classe Point2D
{
...
}
classe Point3D: estende Point2D
{
...
}
12.2.3 Construtores 
Embora não seja forçada, mas sugere-se que o nome começa com construtor “ por ... ” para indicar
como criar o objeto Por exemplo, o construtor de criação de um ponto pode ser “ ByCoordinates ()”.
Se a classe herdar da outra classe, é possível chamar o construtor da classe base chamando
“ Base (...) ”.
Para criar uma instância da classe, instrução de criação uso objeto “ ClassName.ConstructorName (...)” . E se
o nome do construtor é igual ao nome da classe ou uma classe é sem construtor (nesse caso, um
Page 40
construtor padrão será criado internamente), em ambos os casos a instrução de criação de objeto pode ser
simplificada como ClassName (...) .
Exemplo:
classe Point2D
{
construtor ByCoordinates (x, y)
{
...
}
}
classe Point3D: estende Point2D
{
construtor ByCoordinates (x, y, z): base (x, y)
{
...
}
construtor Point3D (){
...
}
}
// cria uma instância do Point3D
p1 = Point3D.ByCoordinates (1, 2, 3);
// cria a outra instância do Point3D
p2 = Point3D ();
12.2.4 Propriedades
Variáveis definidas na classe são propriedades.A inicialização das propriedades pode estar no construtor ou
em definição.
Para distinguir propriedades de outros tipos de variáveis, expressão de acesso de membro
“ This.property_name ” “' ou base.property_name ” poderia ser usado para indicar ‘ property_name ’ é um
propriedade da classe ou propriedade da classe base.
Estendendo anterior Point2D e Point3D exemplo:
classe Point2D
{
x = 0; // inicializa a propriedade "x"
y = 0;
construtor ByCoordinates (x, y)
Page 41
{
this.x = x;
this.y = y;
}
}
classe Point3D: estende Point2D
{
z = 0;
construtor ByCoordinates (x, y, z): base (x, y)
{
this.z = z;
}
construtor Point3D ()
{
x = 1; // é propriedade “x” da classe base
base.y = 1; // é propriedade "y" da classe base
z = 1;
}
}
// cria a outra instância do Point3D
p1 = Point3D ();
// x == 1
x = p1.x;
// atualiza a propriedade "y"
p1.y = 2;
12.2.5 Funções de membro
A definição de funções-membro é igual à definição de função normal. Todas as propriedades são
acessível em funções membro.
12.2.6 Modificadores de acesso
A restrição de acesso às propriedades de classe e membro funções são especificados por rótulos pública ,
protegida e privada . Se nenhum especificador de acesso for especificado para membros, por padrão, eles são públicos.
As seguintes regras se aplicam:
● Os membros públicos podem ser acessados de qualquer lugar dentro e fora da classe.
● Os membros protegidos são acessíveis apenas na classe ou na classe derivada.
● Membros privados são acessíveis apenas na classe.
Exemplo:
Page 42
classe Base
{
prop1 privado;
prop2 protegido;
prop3 público;
private def foo1 ()
{...}
def protegido foo2 ()
{...}
// por padrão é público
def foo3 ()
{
}
}
classe Derived: extends Base
{
barra de definição ()
{
// como "prop1" é privado na base, não é acessível
x = prop1;
// "prop2" está acessível na classe derivada
y = prop2;
// "prop3" está acessível na classe derivada
z = prop3;
}
}
b = Base ();
// como "prop1" é privado, não é acessível fora da classe
// p1 é nulo
p1 = b.prop1;
// como "prop2" está protegido, não é acessível fora da classe
// p2 é nulo
p2 = b.prop2;
// como "prop3" é público, é acessível fora da classep3 = b.prop3;
 
12.2.7 Membros estáticos
Propriedades estáticas e funções de membro estáticas são definidas no nível da classe. Ou seja, a expressão de acesso é
na forma de " ClassName.X " ou " ClassName.Y () '
Page 43
Existem algumas regras:
● É inválido acessar membros estáticos no nível da instância.
● É inválido se uma propriedade estática tiver o mesmo nome que uma propriedade não estática ou um membro estático
A função tem a mesma assinatura que uma função membro não estática.
● Não é necessário ter " ClassName ." prefixo ao chamar membros estáticos na classe.
O exemplo abaixo mostra estas regras:
classe Foo
{
x;
// erro: x foi definido como uma propriedade não estática
estático x;
Y estático;
def foo ()
{
}
// error: foo () foi definido como uma função membro não estática
estática definição foo ()
{
}
barra de definição estática ()
{
// erro: é inválido chamar a função de membro estático em não estático
// função membro
qux ();
}
def qux ()
{
// é bom chamar a função de membro estático no membro não estático
// função
Barra();
}
}
f = Foo ();
// erro: é inválido acessar membros estáticos no nível da instância
r = fY;
// obtém o valor do membro estático "Y"
r = Foo.Y;
// erro: é inválido acessar membros estáticos no nível da instância
r = f.bar ();
Page 44
// chama a função membro estática "bar ()"
r = Foo.bar ();
 
12.2.8 Método _Dispose () 
Se um público _Dispose () método é definido na classe, quando o exemplo é lixo recolhido, este
método será chamado, então _Dispose () pode ser usado para liberar recursos adquiridos por exemplo. Tipicamente,
esse método será gerado automaticamente para as classes FFI.
Exemplo:
classe Diposable
{
flag estático = false;
def _Dispose ()
{
Flag = true;
}
}
[Imperativo]
{
d = descartável ();
// função embutida para forçar a coleta de lixo.
__GC ();
// "d" será coletado de lixo
}
// Disposable.Flag é true
r = Disposable.Flag;