## 类型的显示转换

```c++
// 将变量ch转成无符号的字符类型
(unsigned char) ch;

// (long int)将10显式转为long int类型。
// 这里的显示转换其实是不必要的，因为赋值运算符会自动将右边的值，转为左边变量的类型。
long int y = (long int) 10 + 12;
```

c.md

```dart
assert(int.parse('42') == 42);
assert(int.parse('0x42') == 66);
assert(double.parse('0.50') == 0.5);

assert(num.parse('42') is int);
assert(num.parse('0x42') is int);
assert(num.parse('0.50') is double);

assert(int.parse('42', radix: 16) == 66);

// Convert an int to a string.
assert(42.toString() == '42');
// Convert a double to a string.
assert(123.456.toString() == '123.456');
// Specify the number of digits after the decimal.
assert(123.456.toStringAsFixed(2) == '123.46');
// Specify the number of significant figures.
assert(123.456.toStringAsPrecision(2) == '1.2e+2');
assert(double.parse('1.2e+2') == 120.0);
```

```dart
// Convert an int to a string.
assert(42.toString() == '42');
// Convert a double to a string.
assert(123.456.toString() == '123.456');
// Specify the number of digits after the decimal.
assert(123.456.toStringAsFixed(2) == '123.46');
// Specify the number of significant figures.
assert(123.456.toStringAsPrecision(2) == '1.2e+2');
```

```dart
assert(int.parse('42') == 42);
assert(int.parse('0x42') == 66);
assert(double.parse('0.50') == 0.5);

assert(num.parse('42') is int);
assert(num.parse('0x42') is int);
assert(num.parse('0.50') is double);

assert(int.parse('42', radix: 16) == 66);
```


dart.md

字符串和字节 slice

```go
s := "abc"
b := []byte(s)
s2 := string(b)
```

字符串和数字

```go
x := 123

// 一种方法是用fmt.Sprintf返回一个格式化的字符串
y := fmt.Sprintf("%d", x)

// 另一个方法是用strconv.Itoa(“整数到ASCII”)
fmt.Println(y, strconv.Itoa(x)) // "123 123"

// 不同的进制来格式化数字
fmt.Println(strconv.FormatInt(int64(x), 2)) // "1111011"

// fmt.Printf函数的%b、%d、%o和%x等参数提供功能往往比strconv包的Format函数方便很多
s := fmt.Sprintf("x=%b", x) // "x=1111011"

// 如果要将一个字符串解析为整数，可以使用strconv包的Atoi或ParseInt函数，
// 还有用于解析无符号整数的ParseUint函数：
x, err := strconv.Atoi("123")             // x is an int
y, err := strconv.ParseInt("123", 10, 64) // base 10, up to 64 bits
```

表达式 `T(v)` 将值 v 转换为类型 T。
Go 在不同类型的项之间赋值时需要显式转换。

对于每一个类型 T，都有一个对应的类型转换操作`T(x)`，
用于将 x 转为 T 类型（译注：如果 T 是指针类型，
可能会需要用小括弧包装 T，比如`(*int)(0)`）。
只有当两个类型的底层基础类型相同时，才允许这种转型操作，
或者是两者都是指向相同底层结构的指针类型，
这些转换只改变类型而不会影响值本身。
如果 x 是可以赋值给 T 类型的值，那么 x 必然也可以被转为 T 类型，但是一般没有这个必要。

```go
var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

// 或者，更加简单的形式：
i := 42
f := float64(i)
u := uint(f)


// 字符串和字节slice之间可以相互转换
s := "abc"
b := []byte(s)
s2 := string(b)


// 整数转为字符串
x := 123
y := fmt.Sprintf("%d", x)
fmt.Println(y, strconv.Itoa(x)) // "123 123"
fmt.Println(strconv.FormatInt(int64(x), 2)) // "1111011"
s := fmt.Sprintf("x=%b", x) // "x=1111011"


// 字符串解析为整数
// 可以使用strconv包的Atoi或ParseInt函数，
// 还有用于解析无符号整数的ParseUint函数：
x, err := strconv.Atoi("123")             // x is an int
y, err := strconv.ParseInt("123", 10, 64) // base 10, up to 64 bits
```


go.md

```js
parseInt("v8", 32); // 1000

const string1 = "1";
const number1 = parseInt(string1);
console.log(number1 + 2); // 3
```

```js
// 小数点截取
(10).toFixed(2); // "10.00"
(10.005).toFixed(2); // "10.01"

// 2
console.log(Math.ceil(1.5));
// 1
console.log(Math.floor(1.5));
// 2
console.log(Math.round(1.5));
```

```js
// 10进制转为32进制
(1000).toString(32); // 'v8'
// 32进制转为10进制
parseInt("v8", 32); // 1000
```


js.md

```python
string_1 = "1"
number_1 = int(string_1)
# 3
print(number_1 + 2)
```

```python
import math

# 2
print(math.ceil(1.5))
# 1
print(math.floor(1.5))
# 2
print(round(1.5))
```


python.md

```rust
let decimal = 65.4321_f32;
// 可以显式转换
let integer = decimal as u8;
let character = integer as char;
```

## from

```rust
use std::convert::From;

#[derive(Debug)]
struct Number {
    value: i32,
}

impl From<i32> for Number {
    fn from(item: i32) -> Self {
        Number { value: item }
    }
}

fn main() {
    let num = Number::from(30);
    println!("My number is {:?}", num);
}
```

## into

```rust
use std::convert::From;

#[derive(Debug)]
struct Number {
    value: i32,
}

impl From<i32> for Number {
    fn from(item: i32) -> Self {
        Number { value: item }
    }
}

fn main() {
    let int = 5;
    // 试试删除类型说明
    let num: Number = int.into();
    println!("My number is {:?}", num);
}
```

## TryFrom and TryInto

```rust
use std::convert::TryFrom;
use std::convert::TryInto;

#[derive(Debug, PartialEq)]
struct EvenNumber(i32);

impl TryFrom<i32> for EvenNumber {
    type Error = ();

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        if value % 2 == 0 {
            Ok(EvenNumber(value))
        } else {
            Err(())
        }
    }
}

fn main() {
    // TryFrom

    assert_eq!(EvenNumber::try_from(8), Ok(EvenNumber(8)));
    assert_eq!(EvenNumber::try_from(5), Err(()));

    // TryInto

    let result: Result<EvenNumber, ()> = 8i32.try_into();
    assert_eq!(result, Ok(EvenNumber(8)));
    let result: Result<EvenNumber, ()> = 5i32.try_into();
    assert_eq!(result, Err(()));
}
```

## 解析字符串

```rust
fn main() {
    let parsed: i32 = "5".parse().unwrap();
    let turbo_parsed = "10".parse::<i32>().unwrap();

    let sum = parsed + turbo_parsed;
    println!{"Sum: {:?}", sum};
}
```


数据类型转换