New Crowdin updates

i18n/es/docusaurus-plugin-content-docs/current/API/DataClassClass.md

@@ -1249,10 +1249,16 @@ var $results := ds.MyClass.query("myVectorField <= :1"; $comparisonVector)
 La instrucción **orden by** es soportada en la cadena de consulta para que las entidades en la selección de entidad resultante estén ordenadas por similitud. Por ejemplo:
 
 ```4d
-var $results := ds.MyClass.query("myVectorField > :1 order by myVectorField"; $comparisonVector)  
-  //orden por defecto, la primera entidad es la más parecida
+var $results := ds.MyClass.query("myVectorField > :1 order by myVectorField desc"; $comparisonVector)  
+  //the first entity is the most similar
 ```
 
+:::note
+
+The default order is ascending, although a descending order is usually the most useful for vector similarity queries. Thus, you will usually have to add the `desc` keyword in your vector similarity query strings.
+
+:::
+
 Si el mismo vector aparece varias veces en la cadena de consulta, el orden por se aplicará a los resultados del primero, por ejemplo:
 
 ```4d

i18n/es/docusaurus-plugin-content-docs/current/Concepts/dt_collection.md

@@ -110,6 +110,43 @@ Puede crear dos tipos de colecciones:
 
 Para más información, consulte la sección [Objetos y colecciones compartidos](shared.md).
 
+## Assignment
+
+Collection and [object](./dt_object.md) data types are handled in the 4D language through **references** (i.e., internal pointers), unlike scalar data types (integer, date, etc.). As a result, when assigning a collection to a variable (e.g. `$myVar:=[1;2;3]`), it is the **reference** that is assigned, not the value itself. Any subsequent modification of the *$myVar* variable will therefore be reflected everywhere the original collection is referenced. This follows the same principle as [pointers](./dt_collection.md), except that the *$myVar* variable does not need to be dereferenced.
+
+Por ejemplo:
+
+```4d
+var $col1; $col2 : Collection
+var $o : Object
+
+$col1:=[1;2;3] //a reference to the collection is created
+$col2:=$col1 //both variables share the same collection reference
+$o:={ list:$col1 } //the object stores a reference to the same collection
+
+$col1.push(4)
+//$col2 = [1,2,3,4]
+//$o = {"list":[1,2,3,4]}
+
+$col2[0]:=10
+//$col1 = [10,2,3,4]
+//$o = {"list":[10,2,3,4]}
+
+$o.list.push(5)
+//$col1 = [10,2,3,4,5]
+//$col2 = [10,2,3,4,5]
+
+ASSERT($col1=$col2) //True
+```
+
+This principle applies wherever objects or collections are assigned, including in [parameters](./parameters.md) or [formula](../commands/formula) expressions.
+
+:::note
+
+If you want to create a **deep copy** of a collection, use the [`collection.copy()`](../API/CollectionClass.md#copy) function.
+
+:::
+
 ## Funciones de colección
 
 Las referencias a colecciones 4D se benefician de funciones de clase específicas (a veces llamados *funciones miembro*). Las funciones de colección están listadas en la sección [Referencia de la API de Clase](../API/CollectionClass.md).

i18n/es/docusaurus-plugin-content-docs/current/Concepts/dt_object.md

@@ -28,7 +28,7 @@ Tenga en cuenta que los nombres de las propiedades distinguen entre mayúsculas
 
 :::
 
-Las variables, campos o expresiones de tipo Objeto se gestionan utilizando la [notación de objetos](#properties) estándar o los comandos disponibles en el tema **Objetos (Lenguaje)**. Tenga en cuenta que comandos específicos del tema **Búsquedas**, como `QUERY BY ATTRIBUTE`, `QUERY SELECTION BY ATTRIBUTE` o `ORDER BY ATTRIBUTE`, se pueden utilizar para llevar a cabo el procesamiento en los campos objeto.
+Las variables, campos o expresiones de tipo Objeto se gestionan utilizando la [notación de objetos](#properties) estándar o los comandos disponibles en el tema **Objetos (Lenguaje)**.
 
 Cada valor de propiedad al que se accede a través de la notación de objeto se considera una expresión. Puede utilizar estos valores siempre que se esperen expresiones 4D:
 
@@ -114,6 +114,36 @@ Puede crear dos tipos de objetos:
 - objetos compartidos, utilizando el comando [`New shared object`](../commands/new-shared-object). Estos objetos pueden ser compartidos entre procesos, incluidos los hilos apropiativos. Estos objetos pueden ser compartidos entre procesos, incluidos los hilos apropiativos.
   Para más información, consulte la sección [Objetos y colecciones compartidos](shared.md).
 
+## Assignment
+
+Object and [collection](./dt_collection.md) data types are handled in the 4D language through **references** (i.e., internal pointers), unlike scalar data types (integer, date, etc.). As a result, when assigning an object or a collection to a variable (e.g. `$myVar:={ a:2 }`), it is the **reference** that is assigned, not the value itself. Any subsequent modification of the *$myVar* variable will therefore be reflected everywhere the original object is referenced. This follows the same principle as [pointers](./dt_collection.md), except that the *$myVar* variable does not need to be dereferenced.
+
+Por ejemplo:
+
+```4d
+var $o1; $o2 : Object
+var $col : Collection
+
+$col:=[1;2;3] //a reference to the collection is created
+$o1:={ a:2 ; b:$col } //a reference to the object is created
+$o2:=$o1 //both variables $o1 and $o2 share the reference to the same object
+
+$o1.a:=10 //$o2 = {"a":10,"b":[1,2,3]}
+$o2.a:=20 //$o1 = {"a":20,"b":[1,2,3]}
+$col.push(4) 
+//$o1 = {"a":20,"b":[1,2,3,4]}
+//$o2 = {"a":20,"b":[1,2,3,4]}
+ASSERT($o1=$o2) //True
+```
+
+This principle applies wherever objects or collections are used, including in [parameters](./parameters.md) or [formula](../commands/formula) expressions.
+
+:::note
+
+If you want to create a **deep copy** of an object, use the [`OB COPY`](../commands/ob-copy) command.
+
+:::
+
 ## Propiedades {#properties}
 
 Se accede a los valores de las propiedades de los objetos a través de una cadena de tokens. Se puede acceder a las propiedades de los objetos de dos maneras:

i18n/es/docusaurus-plugin-content-docs/current/Concepts/flow-control.md

@@ -58,6 +58,14 @@ La expresión es TRUE sólo si los dos métodos son TRUE. Sin embargo, incluso s
  End if
 ```
 
+However, the most elegant solution is then to use the [`&&` short-circuit operator](./operators.md#short-circuit-and-operator-) and to write:
+
+```4d
+If (MethodA && MethodB)
+   ...
+End if
+```
+
 El resultado es similar y *MethodB* se evalúa sólo si es necesario.
 
 > **Nota:** el [operador ternario](operators.md#ternary-operator) permite escribir expresiones condicionales de una sola línea y puede reemplazar una secuencia completa de declaraciones If..Else.
@@ -809,3 +817,24 @@ logConsole($message)
 
 ```
 
+## defer (expression)
+
+<details><summary>Historia</summary>
+
+| Lanzamiento | Modificaciones |
+| ----------- | -------------- |
+| 21 R4       | Añadidos       |
+
+</details>
+
+The [`defer`](../commands/defer) command allows you to stack one or more expression(s) that will automatically execute when the current method or function **finishes running**.
+
+Whether you are managing document closings, resetting interprocess flags, or freeing up resources, ensuring that your housekeeping tasks execute flawlessly no matter how or where your function terminates can be handled by `defer` keywords.
+
+```4d
+   //make sure some code is executed at exit
+defer(myCleaningMethod)
+   //Do something...
+```
+
+See the [`defer`](../commands/defer) command description for more information.

i18n/es/docusaurus-plugin-content-docs/current/Concepts/methods.md

@@ -13,13 +13,13 @@ El tamaño máximo de un método está limitado a 2 GB de texto o 32.000 líneas
 
 En el lenguaje 4D, hay varias categorías de métodos. La categoría depende de cómo se les pueda llamar:
 
-| Tipo                                              | Contexto de llamada                                                                                                                                                                                                                     | Acepta los parámetros                      | Descripción                                                                                                                                                                                                                                |
-| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **Métodos proyecto**                              | On demand, when the project method name [is called](../Project/project-method-properties.md)                                                                                                                                            | Sí                                         | Puede contener código para ejecutar acciones personalizadas. Una vez creado un método proyecto, pasa a formar parte del lenguaje del proyecto.                                                             |
-| **Método objeto (widget)**     | Automático, cuando un evento involucra al objeto al que se asocia el método                                                                                                                                                             | No                                         | Propiedad de un objeto formulario (también llamado widget)                                                                                                                                                              |
-| **Método formulario**                             | Automático, cuando un evento involucra al formulario al que se asocia el método                                                                                                                                                         | No                                         | Propiedad de un formulario. Puede utilizar un método formulario para gestionar datos y objetos, pero generalmente es más sencillo y eficiente utilizar un método objeto para estos fines.                  |
-| **Trigger** (o *método tabla*) | Automático, cada vez que se manipulan los registros de una tabla (Añadir, Eliminar y Modificar)                                                                                                                      | No                                         | Propiedad de una tabla. Los triggers son métodos que pueden evitar operaciones "ilegales" con los registros de su base.                                                                                    |
-| **Método base**                                   | Automático, cuando se produce un evento de la sesión de trabajo                                                                                                                                                                         | Sí (predefinido)        | Hay 16 métodos base en 4D.                                                                                                                                                                                                 |
-| **Class**                                         | Automatically called when an object of the class is instantiated or when a function of the class is executed on an object instance in any other methods or in a [database field](../Develop/field-properties.md#class). | sí (funciones de clase) | A **Class** is used to declare and configure the class [constructor](./classes.md#class-constructor), [properties](./classes.md#property), and [functions](./classes.md#function) of objects. Ver [**Clases**](classes.md) |
+| Tipo                                              | Contexto de llamada                                                                                                                                                                                                                     | Acepta los parámetros                      | Descripción                                                                                                                                                                                                                                                                                                    |
+| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Métodos proyecto**                              | On demand, when the project method name [is called](../Project/project-method-properties.md)                                                                                                                                            | Sí                                         | Puede contener código para ejecutar acciones personalizadas. Una vez creado un método proyecto, pasa a formar parte del lenguaje del proyecto.                                                                                                                                 |
+| **Método objeto (widget)**     | Automático, cuando un evento involucra al objeto al que se asocia el método                                                                                                                                                             | No                                         | Propiedad de un objeto formulario (también llamado widget)                                                                                                                                                                                                                                  |
+| **Método formulario**                             | Automático, cuando un evento involucra al formulario al que se asocia el método                                                                                                                                                         | No                                         | Propiedad de un formulario. Puede utilizar un método formulario para gestionar datos y objetos, pero generalmente es más sencillo y eficiente utilizar un método objeto para estos fines.                                                                                      |
+| **Trigger** (o *método tabla*) | Automático, cada vez que se manipulan los registros de una tabla (Añadir, Eliminar y Modificar)                                                                                                                      | No                                         | Propiedad de una tabla. Los triggers son métodos que pueden evitar operaciones "ilegales" con los registros de su base.                                                                                                                                                        |
+| **Método base**                                   | Automático, cuando se produce un evento de la sesión de trabajo                                                                                                                                                                         | Sí (predefinido)        | Hay 16 métodos base en 4D.                                                                                                                                                                                                                                                                     |
+| **Class**                                         | Automatically called when an object of the class is instantiated or when a function of the class is executed on an object instance in any other methods or in a [database field](../Develop/field-properties.md#class). | sí (funciones de clase) | A **Class** is used to declare and configure the class [constructor](./classes.md#class-constructor), [properties](./classes.md#property), and [functions](./classes.md#function) of objects. See [**Classes**](classes.md) and [**Function** class](../API/FunctionClass.md). |
 
 

i18n/es/docusaurus-plugin-content-docs/current/Concepts/operators.md

@@ -21,10 +21,12 @@ Los valores que los operadores afectan son los operandos. En la expresión `1 +
 El **operador de asignación** (`a:=b`) inicializa o actualiza el valor de `a` con el valor de `b`:
 
 ```4d
-$myNumber:=3 //asigna 3 a la variable MyNumber
-$myDate:=!2018/01/21! //asigna un literal de fecha
-$myLength:=Length("Acme") //asigna el resultado del comando (4) a $myLength
-$col:=New collection //$col se inicializa con una colección vacía
+$myNumber:=3 //assigns 3 to $myNumber variable  
+$myDate:=!2026/01/21! //assigns a date literal
+$myLength:=Length("Acme") //assigns the result of the command (4) to $myLength
+$col:=New collection //$col is initialized with an empty collection
+$myObject:={ a:2 ; b:$col } //assigns an object reference to $myObject
+$myObject.a:=3 //assigns a value to an object property
 ```
 
 > NO confunda el operador de asignación `:=` con el operador de comparación de igualdad `=`. Se ha elegido deliberadamente un operador de asignación diferente (y no `=`) para evitar los problemas y la confusión que suelen producirse con == o === en otros lenguajes de programación. Estos errores son a menudo difíciles de reconocer por el compilador y conducen a una solución de problemas que requiere mucho tiempo.