New Crowdin updates

website/i18n/ja.json

@@ -24,7 +24,7 @@
         "title": "DataClassAttribute"
       },
       "API/dataclassClass": {
-        "title": "DataClass"
+        "title": "データクラス"
       },
       "API/datastoreClass": {
         "title": "DataStore"

website/translated_docs/de/API/classClass.md

@@ -52,32 +52,54 @@ This property is **read-only**.
 </details>
 
 <!-- REF #classClass.new().Syntax -->
-**.new()** : 4D.Class<!-- END REF -->
+**.new**( *param* : any { *;...paramN* } ) : 4D.Class<!-- END REF -->
 
 <!-- REF #classClass.new().Params -->
-| Parameter | Typ      |    | Beschreibung            |
-| --------- | -------- |:--:| ----------------------- |
-| Ergebnis  | 4D.Class | <- | New object of the class |
+| Parameter | Typ      |    | Beschreibung                                     |
+| --------- | -------- |:--:| ------------------------------------------------ |
+| param     | any      | -> | Parameter(s) to pass to the constructor function |
+| Ergebnis  | 4D.Class | <- | New object of the class                          |
 <!-- END REF -->
 
 
 #### Beschreibung
 
 The `.new()` function <!-- REF #classClass.new().Summary -->creates and returns a `cs.className` object which is a new instance of the class on which it is called<!-- END REF -->. This function is automatically available on all classes from the [`cs` class store](Concepts/classes.md#cs).
 
-Wird sie in einer nicht-vorhandenen Klasse aufgerufen, wird ein Fehler zurückgegeben.
+You can pass one or more optional *param* parameters, which will be passed to the [class constructor](Concepts/classes.md#class-constructor) function (if any) in the className class definition. Within the constructor function, the [`This`](Concepts/classes.md#this) is bound to the new object being constructed.
 
+If `.new()` is called on a non-existing class, an error is returned.
 
-#### Beispiel
+#### Beispiele
 
 Eine neue Instanz der Klasse Person anlegen:
 
 ```4d
 var $person : cs.Person  
 $person:=cs.Person.new() //create the new instance  
-//$Person contains functions of the class
+//$person contains functions of the class
+```
+
+To create a new instance of the Person class with parameters:
+
+```4d
+//Class: Person.4dm
+Class constructor($firstname : Text; $lastname : Text; $age : Integer)
+    This.firstName:=$firstname
+    This.lastName:=$lastname
+    This.age:=$age
 ```
 
+```4d
+//In a method
+var $person : cs.Person  
+$person:=cs.Person.new("John";"Doe";40)  
+//$person.firstName = "John"
+//$person.lastName = "Doe"
+//$person.age = 40
+```
+
+
 <!-- END REF -->
 
 

website/translated_docs/de/Concepts/classes.md

@@ -19,14 +19,19 @@ Sie können z. B. eine Klasse `Person` mit folgender Definition erstellen:
 Class constructor($firstname : Text; $lastname : Text)
     This.firstName:=$firstname
     This.lastName:=$lastname
+
+Function sayHello()->$welcome : Text
+    $welcome:="Hello "+This.firstName+" "+This.lastName
 ```
 
 In einer Methode erstellen Sie eine "Person":
 
 ```
-var $o : cs.Person //object of Person class
-$o:=cs.Person.new("John";"Doe")
-// $o:{firstName: "John"; lastName: "Doe" }
+var $person : cs.Person //object of Person class  
+var $hello : Text
+$person:=cs.Person.new("John";"Doe")
+// $person:{firstName: "John"; lastName: "Doe" }
+$hello:=$person.sayHello() //"Hello John Doe"
 ```
 
 
@@ -39,7 +44,7 @@ Eine Benutzerklasse in 4D wird über eine spezifische Datei Methode (.4dm) defin
 
 Beim Benennen von Klassen müssen Sie folgende Regeln beachten:
 
-- Ein Klassenname muss mit den [ Schreibregeln für Eigenschaftsnamen](Concepts/dt_object.md#identifier-für-objekteigenschaft) konform sein.
+- A [class name](identifiers.md#classes) must be compliant with [property naming rules](identifiers.md#object-properties).
 - Es wird zwischen Groß- und Kleinschreibung unterschieden.
 - Um Konflikte zu vermeiden, sollten Sie für eine Klasse und eine Tabelle in derselben Anwendung unterschiedliche Namen verwenden.
 
@@ -81,7 +86,7 @@ Um eine neue Klasse zu erstellen:
 
 #### Unterstützung von Code für Klassen
 
-In verschiedenen 4D Entwicklerfenstern (Code-Editor, Compiler, Debugger, Runtime-Explorer) wird Code für Klassen im allgemeinen wie eine Projektmethode mit einigen spezifischen Merkmalen verwaltet:
+In the various 4D windows (code editor, compiler, debugger, runtime explorer), class code is basically handled like a project method with some specificities:
 
 - Im Code-Editor gilt folgendes:
     - Klassen können nicht direkt ausgeführt werden
@@ -136,57 +141,32 @@ $key:=4D.CryptoKey.new(New object("type";"ECDSA";"curve";"prime256v1"))
 
 
 
-## Klassen in Ihrem Code verwenden
-
 
-### Objekt class
+## Objekt Class
 
 Ist in einem Projekt eine Klasse [definiert](#eine-klasse-definieren), wird sie in die 4D Programmiersprache Umgebung geladen. Eine Klasse ist selbst ein Objekt der Klasse ["class"](API/classClass.md). Ein Objekt class hat folgende Eigenschaften und Funktionen:
 
 - String [`name`](API/classClass.md#name)
 - Objekt [`superclass`](API/classClass.md#superclass) (optional, null, wenn nicht vorhanden)
 - Funktion [`new()`](API/classClass.md#new), um Instanzen der Objekte einer Klasse zu setzen.
 
-Zusätzlich kann ein Objekt class verweisen auf:
-
-- Ein Objekt [`constructor`](#class-constructor) (optional),
-- Ein Objekt `prototype` mit Objektnamen [function](#function) (optional).
+In addition, a class object can reference a [`constructor`](#class-constructor) object (optional).
 
 Ein Objekt class ist ein [shared object](shared.md), d. h. es lässt sich aus verschiedenen 4D Prozessen gleichzeitig darauf zugreifen.
 
+### Inheritance
 
+If a class inherits from another class (i.e. the [Class extends](classes.md#class-extends-classname) keyword is used in its definition), the parent class is its [`superclass`](API/classClass.md#superclass).
 
-### Nach Eigenschaft suchen und Prototyp
-
-Alle Objekte in 4D sind intern an ein Objekt class gebunden. Findet 4D eine Eigenschaft nicht in einem Objekt, sucht es im Objekt Prototyp seiner Klasse; wird sie hier nicht gefunden, sucht 4D weiter im Objekt prototype seiner Superklasse, usw. bis es keine Superklasse mehr gibt.
-
-Alle Objekte erben vom Objekt class als ihrer obersten Klasse im Vererbungsbaum.
-
-```4d
-//Class: Polygon
-Class constructor($width : Integer; $height : Integer)
-    This.area:=$width*$height
-
-    //var $poly : Object
-    var $instance : Boolean
-    $poly:=cs.Polygon.new(4;3)
-
-    $instance:=OB Instance of($poly;cs.Polygon)
-    // true
-    $instance:=OB Instance of($poly;4D.Object)
-    // true
-```
-
-Beim Aufzählen der Eigenschaften eines Objekts wird der Prototyp seiner Klasse nicht mitgezählt. Demzufolge geben die Anweisung `For each` und der Befehl `JSON Stringify` nicht Eigenschaften des Objekts prototype der Klasse zurück. Die Eigenschaft des Objekts prototype einer Klasse ist eine interne ausgeblendete Eigenschaft.
-
+When 4D does not find a function or a property in a class, it searches it in its [`superclass`](API/classClass.md#superclass); if not found, 4D continues searching in the superclass of the superclass, and so on until there is no more superclass (all objects inherit from the "Object" superclass).
 
 
 ## Schlüsselwörter für Klassen
 
 In der Definition von Klassen lassen sich spezifische 4D Schlüsselwörter verwenden:
 
-- `Function <Name>` zum Definieren von Member Methods der Objekte.
-- `Class constructor` zum Definieren der Eigenschaften der Objekte (z.B. Prototype).
+- `Function <Name>` to define class functions of the objects.
+- `Class constructor` to define the properties of the objects.
 - `Class extends <ClassName>` zum Definieren der Vererbung.
 
 
@@ -199,13 +179,13 @@ Function <name>({$parameterName : type; ...}){->$parameterName : type}
 // code
 ```
 
-Class Functions sind Eigenschaften des Objekts Prototype der Klasse des Eigentümers. Das sind Objekte der Klasse "Function".
+Class functions are specific properties of the class. They are objects of the [4D.Function](API/formulaClass.md#about-4dfunction-objects) class.
 
-In der Datei mit der Definition der Klasse verwenden Function Deklarationen das Schlüsselwort `Function` und den Namen von Function. Ein Klassenname muss mit den [ Schreibregeln für Eigenschaftsnamen](Concepts/dt_object.md#identifier-für-objekteigenschaft) konform sein.
+In der Datei mit der Definition der Klasse verwenden Function Deklarationen das Schlüsselwort `Function` und den Namen von Function. The function name must be compliant with [property naming rules](Concepts/identifiers.md#object-properties).
 
 > **Tipp:** Namen, die mit einem Unterstrich (_) beginnen, werden beim automatischen Vervollständigen (autocompletion) im 4D Code-Editor unterdrückt und nicht vorgeschlagen. Schreiben Sie z.B. `Function _myPrivateFunction` in `MyClass`, wird das nicht im Code-Editor vorgeschlagen, wenn Sie `"cs.MyClass` eingeben.
 
-Direkt nach dem Namen von Function lassen sich passende [Parameter](#parameter) angeben mit zugewiesenem Namen und Datentyp, inkl. Rückgabeparameter (optional). Beispiel:
+Direkt nach dem Namen von Function lassen sich passende [Parameter](#parameters) angeben mit zugewiesenem Namen und Datentyp, inkl. Rückgabeparameter (optional). Beispiel:
 
 ```4d
 Function computeArea($width : Integer; $height : Integer)->$area : Integer
@@ -226,19 +206,19 @@ Der Befehl `Current method name` gibt für eine Class Function zurück: "*\<Clas
 
 Im Code der Anwendung werden Class Functions als Member Methods der Instanz des Objekts aufgerufen und können [Parameter](#parameter) empfangen, falls vorhanden. Folgende Syntaxarten werden unterstützt
 
-- Verwendung des Operators `()` Zum Beispiel, `myObject.methodName("hello")`
-- Verwendung einer Class Member Method "Function":
-    - `apply()`
-    - `call()`
+- Verwendung des Operators `()` For example, `myObject.methodName("hello")`
+- use of a "4D.Function" class member method:
+    - [`apply()`](API/formulaClass.md#apply)
+    - [`call()`](API/formulaClass.md#call)
 
-> **Thread-Safety Warnung:** Ist eine Class Function nicht thread-safe und wird mit einer Methode mit der Option "In preemptive Prozess starten" aufgerufen:</br> - generiert der Compiler keinen Fehler (im Unterschied zu regulären Methoden),</br> - Gibt 4D nur im laufenden Betrieb einen Fehler aus.
+> **Thread-safety warning:** If a class function is not thread-safe and called by a method with the "Can be run in preemptive process" attribute: - the compiler does not generate any error (which is different compared to regular methods), - an error is thrown by 4D only at runtime.
 
 
 
 
-#### Parameter
+#### Parameters
 
-Function Parameter werden mit Name und Typ des Parameters, getrennt durch Strichpunkt, deklariert. Der Parametername muss mit den [Schreibregeln für Eigenschaftsnamen](Concepts/dt_object.md#identifier-f%C3%BCr-objekteigenschaft) konform sein. Mehrere Parameter (und Typen) werden durch Strichpunkte (;) voneinander getrennt.
+Function parameters are declared using the parameter name and the parameter type, separated by a colon. The parameter name must be compliant with [property naming rules](Concepts/identifiers.md#object-properties). Mehrere Parameter (und Typen) werden durch Strichpunkte (;) voneinander getrennt.
 
 ```4d  
 Function add($x; $y : Variant; $z : Integer; $xy : Object)
@@ -306,13 +286,13 @@ Class Constructor({$parameterName : type; ...})
 
 Eine Function Class Constructor, die [Parameter](#parameters) zulässt, lässt sich zum Definieren einer Benutzerklasse verwenden.
 
-In diesem Fall wird der Class Constructur beim Aufrufen der Class Member Method `new()` mit den Parametern aufgerufen, die optional in der Function `new()` übergeben wurden.
+In that case, when you call the [`new()`](API/classClass.md#new) function, the class constructor is called with the parameters optionally passed to the `new()` function.
 
-Für eine Class Constructor Function gibt der Befehl `Current method name` zurück: "*\<ClassName>.constructor*", z.B. "MyClass.constructor".
+For a class constructor function, the `Current method name` command returns: "*\<ClassName>.constructor*", for example "MyClass.constructor".
 
 
 
-#### Beispiel:
+#### Example:
 
 ```4d
 // Class: MyClass
@@ -341,7 +321,7 @@ $o:=cs.MyClass.new("HelloWorld")
 Class extends <ParentClass>
 ```
 
-Das Schlüsselwort `Class extends` dient in der Deklaration der Klasse zum Erstellen einer Benutzerklasse, die eine Unterklasse einer anderen Benutzerklasse ist. Die Unterklasse erbt alle Functions der übergeordneten Klasse.
+The `Class extends` keyword is used in class declaration to create a user class which is a child of another user class. Die Unterklasse erbt alle Functions der übergeordneten Klasse.
 
 Für Class Extension gelten folgende Regeln:
 
@@ -497,34 +477,35 @@ Das Schlüsselwort `This` gibt eine Referenz auf das gerade bearbeitete Objekt z
 
 In den meisten Fällen bestimmt der Wert von `This`, wie eine Function aufgerufen wird. Es lässt sich während der Ausführung nicht per Zuweisung setzen und kann bei jedem Aufrufen der Funktion anders sein.
 
-Wird eine Formel als Member Method eines Objekts aufgerufen, wird das dazugehörige `This` auf das Objekt gesetzt, wo die Methode aufgerufen wird. Zum Beispiel:
+Wird eine Formel als Member Method eines Objekts aufgerufen, wird das dazugehörige `This` auf das Objekt gesetzt, wo die Methode aufgerufen wird. For example:
 
 ```4d
 $o:=New object("prop";42;"f";Formula(This.prop))
 $val:=$o.f() //42
 ```
 
-Mit der Function [Class Constructor](#class-constructor) (mit der Methode `new()`) wird das dazugehörige `This` an das neue Objekt in Konstruktion gebunden.
+When a [class constructor](#class-constructor) function is used (with the [`new()`](API/classClass.md#new) function), its `This` is bound to the new object being constructed.
 
 ```4d
-  //Class: ob
+//Class: ob
 
 Class Constructor  
+
     // Create properties on This as
     // desired by assigning to them
-    This.a:=42
+    This.a:=42 
 ```
 
 ```4d
-    // in a 4D method  
+// in a 4D method  
 $o:=cs.ob.new()
 $val:=$o.a //42
 ```
 
-> Wird der Superclass Constructor in einem Constructor über das Schlüsselwort [Super](#super) aufgerufen, müssen Sie darauf achten, dass `This` nicht vor dem Superclass Constructor aufgerufen wird, sonst wird ein Fehler generiert. Siehe [dieses Beispiel](#beispiel-1-1).
+> When calling the superclass constructor in a constructor using the [Super](#super) keyword, keep in mind that `This` must not be called before the superclass constructor, otherwise an error is generated. See [this example](#example-1).
 
 
-In jedem Fall bezieht sich `This` auf das Objekt, in dem die Methode aufgerufen wurde, als ob die Methode im Objekt wäre.
+In any cases, `This` refers to the object the method was called on, as if the method were on the object.
 
 ```4d
 //Class: ob
@@ -533,15 +514,15 @@ Function f()
     $0:=This.a+This.b
 ```
 
-Dann können Sie in einer Projektmethode schreiben:
+Then you can write in a project method:
 
 ```4d
 $o:=cs.ob.new()
 $o.a:=5
 $o.b:=3
 $val:=$o.f() //8
 ```
-In diesem Beispiel hat das der Variablen $o zugewiesene Objekt keine eigene Eigenschaft *f*, sondern erbt sie von der dazugehörigen Klasse. Da *f* als eine Methode von $o, aufgerufen wird, bezieht sich das dazugehörige `This` auf $o.
+In this example, the object assigned to the variable $o doesn't have its own *f* property, it inherits it from its class. Da *f* als eine Methode von $o, aufgerufen wird, bezieht sich das dazugehörige `This` auf $o.
 
 
 ## Befehle für Klassen

website/translated_docs/es/API/classClass.md

@@ -52,32 +52,54 @@ This property is **read-only**.
 </details>
 
 <!-- REF #classClass.new().Syntax -->
-**.new()** : 4D.Class<!-- END REF -->
+**.new**( *param* : any { *;...paramN* } ) : 4D.Class<!-- END REF -->
 
 <!-- REF #classClass.new().Params -->
-| Parameter | Type     |    | Description             |
-| --------- | -------- |:--:| ----------------------- |
-| Result    | 4D.Class | <- | New object of the class |
+| Parameter | Type     |    | Description                                      |
+| --------- | -------- |:--:| ------------------------------------------------ |
+| param     | any      | -> | Parameter(s) to pass to the constructor function |
+| Result    | 4D.Class | <- | New object of the class                          |
 <!-- END REF -->
 
 
 #### Description
 
 The `.new()` function <!-- REF #classClass.new().Summary -->creates and returns a `cs.className` object which is a new instance of the class on which it is called<!-- END REF -->. This function is automatically available on all classes from the [`cs` class store](Concepts/classes.md#cs).
 
-If it is called on a non-existing class, an error is returned.
+You can pass one or more optional *param* parameters, which will be passed to the [class constructor](Concepts/classes.md#class-constructor) function (if any) in the className class definition. Within the constructor function, the [`This`](Concepts/classes.md#this) is bound to the new object being constructed.
 
+If `.new()` is called on a non-existing class, an error is returned.
 
-#### Example
+#### Examples
 
 To create a new instance of the Person class:
 
 ```4d
 var $person : cs.Person  
 $person:=cs.Person.new() //create the new instance  
-//$Person contains functions of the class
+//$person contains functions of the class
+```
+
+To create a new instance of the Person class with parameters:
+
+```4d
+//Class: Person.4dm
+Class constructor($firstname : Text; $lastname : Text; $age : Integer)
+    This.firstName:=$firstname
+    This.lastName:=$lastname
+    This.age:=$age
 ```
 
+```4d
+//In a method
+var $person : cs.Person  
+$person:=cs.Person.new("John";"Doe";40)  
+//$person.firstName = "John"
+//$person.lastName = "Doe"
+//$person.age = 40
+```
+
+
 <!-- END REF -->