# DataTypes

**Write in front: I am not a native English speaker, and my English is poor. Sorry for that, and if you want help me , just submit PR. Thank you!**

## Variable declaration

* langX is a weak-type script language.
* Do not need a specific type.
* 如果一个变量直接赋值， 则会自动为其声明。

**Attention**

* 默认情况下， langX 使用的变量会穿越当前的 调用环境。（下面会详细举例）
* 可以使用关键字限制这个情况。

## Numeric

langX has two numeric types: Integer and Double.

Integer: `1,2,3,500,...`

Double: `1.0,0.999,100.661115,...`

Code Example:

```
a = 1;
b = 2;

c = 0.55;
d = 15.66105;
```

## String

What is enclosed in double quotation marks is called a string.

Code Example:

```
a = "hello";
b = "tom";

// plus two or more strings
c = "this is a " + " string!";
```

## Function （lambda expr）

In langX , we use symbol `=>` as the function keyword and lambda keyword.

Code Example:

```
// Function declaration
func => (){
    println("this is in function.");
}

// call function
func();

// 函数赋值给变量
varFunc = func;  

// this is also call function: func
varFunc();


// lambda expr declaration
noNameFunc = ( a, b ) => {
    println("arg a: " + a);
    println("arg b: " + b);
}

// call lambda 
noNameFunc(1,2);
```

函数`func`赋值给变量`varFunc`之后，varFunc就保存了函数func的引用， 之后就可以通过变量varFunc对函数func进行调用。

而 变量`noNameFunc`保存的是对`lambda表达式`的引用。

### 引用穿透调用环境

在函数调用的默认情况下， 变量是会穿透的。

看下面的代码。

```
outerVar = "in the out";

func => (){
    println("func: " + outerVar);
}

func();    // 此时会输出 in the out


funcTemp => (){
  println("enter funcTemp");

    outerVar = "xx " ;
  func();

  println("leave funcTemp");
}

funcTemp();
println("out: " + outerVar);


// 下面是结果输出
// func: in the out
// enter funcTemp
// func: xx
// leave funcTemp
// out: xx
```

如果你不想他们穿透， 可以考虑使用 `local` 关键字声明变量， 或者使用`restrict` 关键字

下面简单介绍一下 `restrict` 关键字的使用。

```
funa => {
  print("in funa\n");
  a=b=c=1;
  funb();
}

funb => {
  // 当限定之后， 在funb 就看不到 funa 里面的变量了
  restrict ;
  print("in funb\n");
  d1 = a ;
  print("d1: " + d1 + "\n");
}

print("will start funa\n");
funa();

// 下面是输出
// will start funa
// in funa
// in funb
// d1: null
```

## Class

Format: `ClassName { classBody }`

Code Example:

```
// code from scripts/class1.lx script
// Class declaration
Student {
    // member variable declaration
  name;
  age = 10 ;

    // Same name with class, this is a constructor.
    // The destructor function starts with a '~' symbol.
  Student => (name,age){
    this.name = name;
        this.age = age;
        printInfo("in ctor.");
  }

  a => { print("hello,a!\n");}

  printInfo => (a3){ print("name: " + name + "\n");  print("age: " + age + "\n" ); print("a3: " + a3 + "\n");}

}

// Use keywork 'new' to get a class instance.
s2 = new Student("hideDragon",20);
b = s2.age;
c = s2.name;
print("b: " + b + "\n");
print("c: " + c + "\n");

s1 = s2;
s1.age = 10 ;
s1.name = "Mr.Ming";
s2.printInfo("wocao! keyile ? ");

Class2{

}

c1 = new Class2();

// Print info below.
// name: hideDragon
// age: 20
// a3: in ctor.
// b: 20
// c: hideDragon
// name: Mr.Ming
// age: 10
// a3: wocao! keyile ?
```

**Attention**

* langX do not have `private` keyword, all class and all member in class is public.
* Keyword `extends` can let you extends other class. （More info:`scripts/extends1.lx`)
* Type check keyword: `is`  ( More info:  `scripts/typejudge1.lx` )
* Operators function override is supported. 
* Keyword `auto` can extend the original class content. （More info: `scripts/classauto1.lx`）


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://aincvy.gitbook.io/langx/english-incomplete/en/datatypes.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.