**Descripción de los tipos de datos integrados de Pharo**

We provide an overview of the built-in data types with dediacted syntax provided by Pharo, namely booleans, characters, strings, symbols, arrays and blocks.

**TRADUCCIÓN** Proporcionamos una visión general de los tipos de datos incorporados con sintaxis definida proporcionada por Pharo, a saber, booleanos, caracteres, cadenas, símbolos, matrices y bloques.

Smalltalk has just six reserved keywords, each of which represents a particular object value.

**TRADUCCIÓN** Smalltalk tiene solo seis palabras clave reservadas, cada una de las cuales representa un valor de objeto particular.

`nil` represents the default value of an uninitialized variables, and is the unique instance of the class {{gtClass:name=UndefinedObject}}. You can test if a variable is nil bey sending it `#isNil`:

**TRADUCCIÓN** nil' representa el valor predeterminado de una variable no inicializada y es la instancia única de la clase {{gtClass:name=UndefinedObject}}. Puedes probar si una variable es nula enviándola '#isNil':

**PREGUNTA** ¿Porqué para nil' solo se tiene una única clase?

**TRADUCCIÓN** 'true' y 'false' son booleanos, que se describen a continuación.

`self` and `super` are used in methods, and both represent the receiver. The difference is the way in which methods are looked up when they are sent messages. For details, see [[Understanding self and super]].

**TRADUCCIÓN** 'self' y 'super' se usan en los métodos, y ambos representan al receptor. La diferencia es la forma en que se buscan los métodos cuando se envían mensajes. Para obtener más información, consulte [[Comprender el yo y super]].

`thisContext` represents the reification of the run-time stack. For details, see [[Understanding reflection]].

**TRADUCCIÓN** thisContext' representa la reificación de la pila en tiempo de ejecución. Para obtener más información, consulte [[Comprensión de la reflexión]].

**TRADUCCIÓN** En Smalltalk, todo es un objeto, incluso los booleanos.

`true` and `false` are the unique instances, respectively, of the classes {{gtClass:name=True}} and {{gtClass:name=False}}, both subclasses of {{gtClass:name=Boolean}}:

**TRADUCCIÓN** true' y 'false' son las instancias únicas, respectivamente, de las clases {{gtClass:name=True}} y {{gtClass:name=False}}, ambas subclases de {{gtClass:name=Boolean}}:

GtMondrianDomainExamples new classHierarchyFor: Boolean withAllSubclasses

{{gtClass:name=Boolean}} consists mostly of abstract methods that are differently implemented by each of its subclasses, and generic methods that are the same for both.

**TRADUCCIÓN** consiste principalmente en métodos abstractos que son implementados de manera diferente por cada una de sus subclases, y métodos genéricos que son los mismos para ambos.

Have a look at the different `&` method implementations of `true` and `false` (click on the grey triangles):

**TRADUCCIÓN** Eche un vistazo a las diferentes implementaciones del método '&' de 'true' y 'false' (haga clic en los triángulos grises):

Numbers are also organized as a hierarchy, with {{gtClass:name=Number}} as the abstract root of the hierarchy:

**TRADUCCIÓN** Los números también se organizan como una jerarquía, con {{gtClass:name=Number}} como la raíz abstracta de la jerarquía:

GtMondrianDomainExamples new classHierarchyFor: Number withAllSubclasses

Smalltalk provides dedicated syntax for several kinds of numbers. Integers can be expressed either in plain decimal or radix syntax. Here we see decimal as well as binary and hexidecimal notations:

**TRADUCCIÓN** Smalltalk proporciona sintaxis dedicada para varios tipos de números. Los enteros se pueden expresar en sintaxis decimal simple o radix. Aquí vemos notaciones decimales, binarias y hexadecimales:

**PREGUNTA** ¿En número siempre se implementara: los enteros, decimales para tener una jeraquia?

The maximum size of a {{gtClass:name=SmallInteger}} is:

**TRADUCCIÓN** El tamaño máximo de {{gtClass:name=SmallInteger}} es:

However, if you increment this value, Pharo automatically converts it to a {{gtClass:name=LargeInteger}}:

**TRADUCCIÓN** Sin embargo, si incrementa este valor, Pharo lo convierte automáticamente en {{gtClass:name=LargeInteger}}:

Decrementing this value will, of course, result in a SmallInteger again.

**TRADUCCIÓN** Disminuir este valor, por supuesto, dará como resultado un SmalInteger nuevamente.

**TRADUCCIÓN** Smalltalk puede tratar felizmente con enteros muy grandes:

Floats can be expressed either using plain floating point or scientific notation:

**TRADUCCIÓN** Los flotadores se pueden expresar usando coma flotante simple o notación científica:

There is no dedicated syntax for fractions. Instead the factory method `/` is used as a conmvenient way to create them:

**TRADICCIÓN** No hay sintaxis dedicada para fracciones. En su lugar, el método de fábrica '/' se utiliza como una forma conmvenient de crearlos:

Characters are prefeixed by a dollar sign (`$`), while strings are dekimited by single quotes (`'`):

**TRADUCCIÓN** Los caracteres están precedidos por un signo de dólar ('$'), mientras que las cadenas se dekimitan con comillas simples ('''):

**PREGUNTA** ¿En los caracteres y simbolos se debén tener en cuenta para escribir, o crear la estructura? ¿O se tienen que tener en cuenta las clases para escribir el mensaje y enviarlo?

Untypeable characters can be created by sending dedicated instance creation methods to the {{gtClass:name=Character}} class:

**TRADUCCIÓN** Se pueden crear caracteres no escribibles enviando métodos de creación de instancias dedicados a la clase {{gtClass:name=Character}}:

Note that we can concatenate strings by sending the binary `#,` message, while characters can be converted to strings by sending the `#asString` message.

**TRADUCCIÓN** Tenga en cuenta que podemos concatenar cadenas enviando el mensaje binario '#', mientras que los caracteres se pueden convertir en cadenas enviando el mensaje '#asString'.

We can compare the *values* of two objects with the `#=` message, and their *identity* with the `#==` message. Two strings can have the same value but be two separate objects:

**TRADUCCIÓN** Podemos comparar los *valores* de dos objetos con el mensaje '#=', y su *identidad* con el mensaje '#=='. Dos cadenas pueden tener el mismo valor pero ser dos objetos separados:

*Symbols* are similar to strings, but start with a hash (#). They have the added property that they are globally unique.

**TRADUCCIÓN** Los símbolos son similares a las cadenas, pero comienzan con un hash (#). Tienen la propiedad añadida de que son únicos a nivel mundial.

Arrays are a very basic form of Sequenceable Collection, as seen in this extract of the {{gtClass:name=Collection}} hierarchy:

**TRADUCCIÓN** Las matrices son una forma muy básica de colección secuenciable, como se ve en este extracto de la jerarquía {{gtClass:name=Collection}}:

GtMondrianDomainExamples new classHierarchyFor: { Collection. SequenceableCollection. ArrayedCollection. Array. String. ByteString. Symbol. OrderedCollection. }

If you need a list of objects, you will normally work with a growable {{gtClass:name=OrderedCollection}}, but fixed-size Arrays are also convenient as Pharo provides dedicated syntax for both *literal* and *dynamic* arrays.

**TRADUCCIÓN** Si necesita una lista de objetos, normalmente trabajará con un {{gtClass:name=OrderedCollection}} cultivable, pero las matrices de tamaño fijo también son convenientes ya que Pharo proporciona sintaxis dedicada para matrices *literales* y *dinámicas*.

**PREGUNTA** ¿Comó reconocer las matrices literales y dinamicas ?

**Literal arrays** are computed at parse time. They are expressed as a hash (`#`) followed by a list of literal values enclosed in parentheses:

**TRADUCCIÓN** ** Las matrices literales** se calculan en el momento del análisis. Se expresan como un hash ('#') seguido de una lista de valores literales entre paréntesis:

**PREGUNTAS** ¿En las matrices literales siempre se pondra el (#) ?

Note that, although we can have nested literal arrays, no expressions are dynamically evaluated, so `3`, `/`, and `4` are treated as three separate literals.

**TRADUCCIÓN** Tenga en cuenta que, aunque podemos tener matrices literales anidadas, no se evalúan dinámicamente ninguna expresión, por lo que '3', '/' y '4' se tratan como tres literales separados.

**Dynamic arrays** are evaluated at run time. They consist of a sequence of expressions delimited by curly braces and separated by periods:

**TRADUCCIÓN** **Las matrices dinámicas** se evalúan en tiempo de ejecución. Consisten en una secuencia de expresiones delimitadas por llaves y separadas por puntos:

**PREGUNTAS** ¿En las matrices dinamicas siempre se pondra las llaves ({) ? esto me sirve para diferenciarlas de las literales ?

It is common to use array syntax to build a list, and then send it `#asOrderedCollection` to convert it:

**TRADUCCIÓN** Es común usar la sintaxis de matriz para crear una lista y luego enviarla '#asOrderedCollection' para convertirla:

Blocks are Smalltalks anonymous functions, or *lambdas*. They are expressed as a sequence of statements enclosed in square brackets.

**TRADUCCIÓN** Los bloques son funciones anónimas de Smalltalks, o *lambdas*. Se expresan como una secuencia de declaraciones entre corchetes.

A block is evaluated by sending it the message `#value`:

**TRADUCCIÓN** Un bloque se evalúa enviándole el mensaje '#value':

Blocks may also declare a number of formal parameters, as well as local temporary variables:

**TRADUCCIÓN** Los bloques también pueden declarar una serie de parámetros formales, así como variables temporales locales:

To evaluate a block with one argument, send it `#value:`. To evaluate one with two arguments, send it `#value:value:`, and so on.

**TRADUCCIÓN** Para evaluar un bloque con un argumento, envíelo '#value:'. Para evaluar uno con dos argumentos, envíelo '#value:value:', y así sucesivamente.ption

A block is a *closure*, i.e., it may capture any variables in its lexical environment. Even if the value of the block is passed out to other environments, it continues to hold references to any of the captuired variables:

**TRADUCCIÓN** Un bloque es un *cierre*, es decir, puede capturar cualquier variable en su entorno léxico. Incluso si el valor del bloque se pasa a otros entornos, continúa manteniendo referencias a cualquiera de las variables cautivadas:

*Caveat:* Although the return operator (`^`) may be used within a block, its effect is not to return from the block, but to return from the enclosing method.

**TRADUCCIÓN** Advertencia: Aunque el operador de retorno ('^') puede usarse dentro de un bloque, su efecto no es regresar del bloque, sino regresar desde el método de cierre.

**PREGUNTA** ¿ Es decir que no se puede modificar el bloque, si no que se regresa al inicio?