文档章节

rust02语法

AllenOR灵感
 AllenOR灵感
发布于 2017/09/10 01:18
字数 2766
阅读 1
收藏 0
点赞 0
评论 0

 

单引号和双引号

错误的写法
fn main() {
    println!('hello world');
}


# 错误信息
error: character literal may only contain one codepoint: ')
 --> src/main.rs:2:26
  |
2 |     println!('hello world')
                             ^^
正确的写法
fn main() {
    println!("hello world");
}
小结

变量定义全部采用双引号, 不能采用单引号。

 

行结束符 ;

错误的写法
fn main() {
    println!("hello world")
    println!("sssssssssss")
}


# 错误信息
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `println`
 --> src/main.rs:3:5
  |
2 |     println!("hello world")
  |                            - expected one of `.`, `;`, `?`, `}`, or an operator here
正确的写法
fn main() {
    println!("hello world");
    println!("sssssssssss");
}
小结

每行执行代码后面最好带上一个行结束符;

 

缩进

无缩进(支持)
fn main() {
println!("hello world"); 
}
空格缩进(支持)
fn main() {
    println!("hello world");
}
tab缩进(支持)
fn main() {
        println!("hello world");
}
小结

rust 对缩进没有要求, 但是鼓励采用4个空格来对代码块进行缩进.

 

main特殊函数

直接将代码暴露在全局作用域中, 也就是说不写main.
println!("hello world");


# 报错信息
error: macros that expand to items must either be surrounded with braces or followed by a semicolon
 --> <println macros>:2:9
  |
2 | print ! ( concat ! ( $ fmt , "\n" ) ) ) ; ( $ fmt : expr , $ ( $ arg : tt ) *
  |         ^^^^^^^^^^^^^^^^^^^
将代码封装在函数中, 不写main.
fn simple() {
    println!("hello world");
}


# 报错信息
error: main function not found
正确的写法
fn simple() {
    println!("hello world");
}

fn main() {
    simple();
}
main函数不能定义参数
fn main(first: i32, second: f64) {     // 不能定义参数
    println!("{} {}", first, second)
}
main函数不能定义返回值
fn main() -> String {                   // 不能定义返回值
    let s = String::from("hello");
    s
}
普通函数使用return返回值
fn simple_function() -> i32 {
    let s = 10;
    return s
}

fn main() {
    let s = simple_function();
    println!("{}", s)
}
普通函数不用return返回值(官方推荐、源码规范)
fn simple_function() -> i32 {
    let s = 10;
    s
}

fn main() {
    let s = simple_function();
    println!("{}", s)
}
小结
  1. 在全局作用域中不能直接撰写执行类型的语句。
  2. main特殊函数, 是所有程序的入口, 所以封装好所有代码之后, 必须放入到main中被rust识别和运行。

 

变量

变量不能定义在函数外
let s = "a";

fn main() {
    println!("hello world! {}", s)
}


# 报错信息
error: expected item, found `let`
 --> main.rs:1:1
  |
1 | let s = "a";
  | ^^^



# 正确的写法
fn main() {
    let s = "a";   // 变量定义写在函数内
    println!("hello world! {}", s);
}
变量不能直接被打印
fn main() {
    let s = "a";
    println!(s);
}

# 报错信息
error: expected a literal
 --> main.rs:3:14
  |
3 |     println!(s);
  |              ^



# 正确的写法
fn main() {
    let s = "a";
    let x = "xxx";
    println!("{} {}", s, x);
}
变量默认不能被修改
fn main() {
    let s = 1;
    s += 2;
    println!("{}", s)
}

# 报错信息
error[E0384]: re-assignment of immutable variable `s`
 --> main.rs:3:5
  |
2 |     let s = 1;
  |         - first assignment to `s`
3 |     s += 2;
  |     ^^^^^^ re-assignment of immutable variable



# 正确的写法
fn main() {
    let mut s = 1;
    s += 2;
    println!("{}", s);
}
可更改变量必须类型相同
fn main() {
    let mut s = 10;
    s += 'abc';
}

# 报错
error: character literal may only contain one codepoint: 'abc'
  --> main.rs:25:10
   |
25 |     s += 'abc';
   |          ^^^^^

error: aborting due to previous error(s)
变量遮盖(Shadowing)
fn main() {
    let s = 1;
    let s = 2 + 10;
    println!("{}", s);
}


# 编译时报警告, 运行时正常; 编译器认为这种写法并不符合规范
# 但也是可以运行的, 因为第一个`let s = 1`没有被使用就被
# 覆盖掉了, 这种情况完全可以不用定义这行代码.
   Compiling datatype v0.1.0 (file:///opt/learn_rust/datatype)
warning: unused variable: `s`
 --> src/main.rs:2:9
  |
2 |     let s = 1;
  |         ^
  |
  = note: #[warn(unused_variables)] on by default

    Finished dev [unoptimized + debuginfo] target(s) in 0.46 secs
     Running `target/debug/datatype`
12



# 正确的Shadowing写法
fn main() {
    let s = 1;
    let s = s + 10;
    println!("{}", s);
}

 
 

变量赋值

整数类型变量
fn main() {
    // "i32"   
    // 公式: -(2 ** (32 - 1))  ~  (2 ** (32 - 1)) -1
    // 结果: -2147483648     ~   2147483647
    let s = 150;          
    println!("{}", s);    
}


fn main() {
    // "u32"   
    // 公式: 0 ~ (2 ** (32 - 1)) -1
    // 结果: 0 ~  4294967295
    let s: u32 = 4294967295;          
    println!("{}", s);    
}
浮点类型变量
fn main() {
    let s = 3.14;       // "f64"
    println!("{}", s);
}
字符串变量
fn main() {
    let s = "hello";      // "&str"
    println!("{}", s);
}
数组数字变量
fn main() {
    let s = [1, 2, 3, 4];   // "[i32; 4]"
    println!("{}", s);
}



# 编译时报错,
   Compiling datatype v0.1.0 (file:///opt/learn_rust/datatype)
error[E0277]: the trait bound `[{integer}; 4]: std::fmt::Display` is not satisfied
 --> src/main.rs:3:20
  |
3 |     println!("{}", s);
  |                    ^ the trait `std::fmt::Display` is not implemented for `[{integer}; 4]`
  |
  = note: `[{integer}; 4]` cannot be formatted with the default formatter; try using `:?` instead if you are using a format string
  = note: required by `std::fmt::Display::fmt`

error: aborting due to previous error

error: Could not compile `datatype`.

To learn more, run the command again with --verbose.



# 正确的写法
fn main() {
    let s = [1, 2, 3, 4];     // "[i32; 4]"
    println!("{:?}", s);
}
数组字符串变量
fn main() {
    let s = ["a", "b", "c"];     // "[&str; 3]"
    println!("{:?}", s);
}
数组混搭元素
# 数组中的变量只能是相同类型的, 下面这个例子会报错, 详细的介绍请参考这里:
# https://rustbyexample.com/primitives/array.html  

fn main() {
    let s = ["a", 1, 2, "b"];     
    println!("{:?}", s);
}

error[E0308]: mismatched types
  --> main.rs:12:19
   |
12 |     let s = ["a", 1, 2, "b"];
   |                   ^ expected &str, found integral variable
   |
   = note: expected type `&str`
              found type `{integer}`

error: aborting due to previous error(s)




# 数组中的变量只能是相同类型, 并且元素内的结构也要保持一直.
# 错误的写法
fn main() {
    let s = [
        ["a", "b", "c", "d"],
        ["e", "f", "g", "h", "i"],
    ];   
    println!("{:?}", s);
}

# 正确的写法
fn main() {
    let s = [                               // "[[&str; 4]; 6]"
        ["a", "b", "c", "d"],
        ["e", "f", "g", "h"],
        ["i", "j", "k", "l"],
        ["m", "n", "o", "p"],
        ["q", "r", "s", "t"],
        ["q", "r", "s", "t"],
    ];  
    println!("{:?}", s);
}

# 正确的写法
fn main() {
    let s = [                               // "[(&str, i32); 6]"
        ("a", 1), ("b", 2), ("c", 3),
        ("d", 4), ("e", 5), ("f", 6),
    ];   
    println!("{:?}", s);
}
元祖数字变量
fn main() {
    let s = (1, 2, 3, 4, 5);                // "(i32, i32, i32, i32, i32)"
    println!("{:?}", s);
}
元祖字符串变量
fn main() {
    let s = ("a", "b", "c");                // "(&str, &str, &str)"
    println!("{:?}", s);
}
元祖混搭变量
fn main() {
    let s = (                               
        "a", 1, 2, "b",                     // "(&str, i32, i32, &str, 
        [3, 4], ["c", "d"],                 //   [i32; 2], [&str; 2], 
        [[4, 5], [6, 7]],                   //   [[i32; 2]; 2], 
        [["e", "f"], ["g", "h"]]            //   [[&str; 2]; 2])"
    );
    println!("{:?}", s);
}

 

我是如何打印这些变量类型的?
// 使用rust-nightly版本.
// 代码参考: https://users.rust-lang.org/t/get-the-type-of-a-var/3618/2

#![feature(core_intrinsics)]

use std::intrinsics::type_name;

fn test_type<T>(_: T) {
    println!("{:?}", unsafe { type_name::<T>() });
}

fn main() {
    let s = (
        "a", 1, 2, "b",
        [3, 4], ["c", "d"],
        [[4, 5], [6, 7]],
        [["e", "f"], ["g", "h"]]
    );
    test_type(s);
}

 
 

常量

字符串常量
const program_language: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}!", hello, program_language);
}


# 编译时报警告, 运行时正常;
# 编译器认为常量的变量名应该是由大写字母构成的;
   Compiling datatype v0.1.0 (file:///opt/learn_rust/datatype)
warning: constant `program_language` should have an upper case name such as `PROGRAM_LANGUAGE`
 --> src/main.rs:1:1
  |
1 | const program_language: &'static str = "Rust";
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: #[warn(non_upper_case_globals)] on by default

    Finished dev [unoptimized + debuginfo] target(s) in 0.43 secs
     Running `target/debug/datatype`
Hello Rust!



# 正确的写法
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}!", hello, PROGRAM_LANGUAGE);
}
浮点常量
const PROGRAM_VERSION: f64 = 1.18;
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}: {}!", hello, PROGRAM_LANGUAGE, PROGRAM_VERSION);
}
整数常量
# 数字可以用下划线来标识, 不影响实际的数字数值, 便于阅读.
const NUMBER: i32 = 100_000_000;

fn main() {
    println!("{}", NUMBER);     // 输出: 100000000 
}


# 有符号整数: "i32"     i == sign == 有符号整数(-表示负数)
# 公式: -(2 ** (32 - 1))  ~  (2 ** (32 - 1)) -1
# 结果: -2147483648     ~   2147483647
const ROLLBACK_VERSION: i32 = 2;  
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}: {}!", hello, PROGRAM_LANGUAGE, ROLLBACK_VERSION);
}




# 无符号整数: "u32"     u == unsign == 无符号整数(必须是正整数)
# 公式: 0 ~ (2 ** (32 - 1)) -1
# 结果: 0 ~  4294967295
const ROLLBACK_VERSION: i32 = 2;  
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}: {}!", hello, PROGRAM_LANGUAGE, ROLLBACK_VERSION);
}
数组数字常量
const DATA_TYPE_ARRAY: &'static [i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



# 严谨的写法
const DATA_TYPE_ARRAY: &'static [i32; 10] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}
数组字符串常量
const DATA_TYPE_ARRAY: &'static [&'static str] = &["a", "b"];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



# 严谨的写法
const DATA_TYPE_ARRAY: &'static [&'static str; 2] = &["a", "b"];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}
数组数组常量
# 数组中嵌套数组
const DATA_TYPE_ARRAY: [[i32; 2]; 2] = [[1, 2], [3, 4]];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



# 数组中嵌套元祖
const DATA_TYPE_ARRAY: [(&str, i32); 2] = [("a", 1), ("b", 2)];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}
元祖字符串常量
const DATA_TYPE_ARRAY: (&str, &str, &str, i32, i32, i32) = ("a", "b", "c", 1, 2, 3);

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



# 严谨的写法
const DATA_TYPE_ARRAY: (
    &'static str, &'static str, &'static str, i32, i32, i32
) = ("a", "b", "c", 1, 2, 3);

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}

 
 

循环

for循环数组(迭代)
# 错误的写法
fn main() {
    let a = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    for i in a {
        println!("{}", i)
    }
}


# 正确的写法
fn main() {
    let a = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    for i in a.iter() {
        println!("{}", i)
    }
}
for循环迭代对象(迭代)
# 1..9 == [1,2,3,4,5,6,7,8,9].iter()
# 1..9 == Iter(1,2,3,4,5,6,7,8,9)
# 1..9是一个迭代对象
fn main() {
    for i in 1..9 {
        println!("{}", i)
    }
}


# 反转数组迭代对象排列顺序
fn main() {
    for i in (1..9).rev() {
        println!("{:?}", i)
    }
}

# 排列顺序等同于下面的代码
fn main() {
    let a = [1,2,3,4,5,6,7,8,9];
    for i in a.iter().rev() {
        println!("{:?}", i)
    }
}
for循环continue关键字
# 从30开始打印
fn main() {
    let a = 1..100;
    for i in a {
        if i < 30 {
            continue
        }
        println!("{:?}", i)
    }
}
for循环break关键字
# 当大于30时,就退出循环
fn main() {
    let a = 1..100;
    for i in a {
        println!("{:?}", i);
        if i > 30 {
            break
        }
    }
}
while循环
# 当小于30时, 持续循环
fn main() {
    let mut a = 1;
    while a < 30 {
        println!("{}", a);
        a += 1
    }
}


# 当小于30时, 持续循环
fn main() {
    let mut a = 1;
    while true {
        if a < 30 {
            println!("{}", a);
        } else {
            break
        }
        a += 1
    }
}
loop循环
fn main() {
    let mut a = 1;
    loop {
        if a < 30 {
            println!("{}", a)
        }
        a += 1
    }
}

while true 和 loop 有什么区别?

从循环的角度看它们没有区别.
从编译器的角度看, while 后面时一个条件句的解析, 而loop则没有条件句的解析, 因此loop理论上要比while更快.
从程序员的角度看, while是用来做单个具体业务逻辑判断; 而loop则是用来做更宏观的模块代码设计使用, 把逻辑判断依托于抽象层去完成, 例如read_line获取用户输入来判断是否要继续或退出.

 
 

枚举

枚举是用来框定一个对象的所有属性定义, 确保程序在运行过程中涉及到该对象时, 输入输出是在定义范围内而不是超出预期之外的值.

枚举成员是特殊的类型值

枚举允许不它的成员不是一个intstrStringArrayTuple, 而可以是一个特殊的像是变量名称一样的标识.

#[derive(Debug)]        // trait
enum UserRole {         // 枚举对象
    Admin,              // 枚举成员
    Manager,            
    Employee
}


fn main() {
    let admin = UserRole::Admin;        // 枚举可以直接赋值
    let manager = UserRole::Manager;    
    let employee = UserRole::Employee;
    println!("{:?} {:?} {:?}", admin, manager, employee);
    println!("{:?}", UserRole::Admin);  // 枚举没有具体值,所以不存在所有权。
}
枚举匹配
#[derive(Debug)]
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}


fn value_in_cents(coin: Coin) -> i32 {
    match coin {
        Coin::Penny => {
            println!("Match Penny");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}


fn main() {
    println!("{:?}", value_in_cents(Coin::Penny))
}
枚举嵌套
#[derive(Debug)]      // trait
enum UsState {        // 枚举对象
    Alabama,          // 枚举成员
    Alaska,
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),     // 枚举嵌套, 为Quarter这个枚举成员限定一个范围.
}

fn value_in_cents(coin: Coin) -> i32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        // 这里 state 可以随便定义,例如 abc
        Coin::Quarter(state) => {
            // 如果state变量发生变化, 引用时也要跟着对应起来.
            println!("State quarter from {:?}!", state);
            25
        },
    }
}

fn main() {
    println!("{:?}", value_in_cents(Coin::Penny));
    println!("{:?}", value_in_cents(Coin::Nickel));
    println!("{:?}", value_in_cents(Coin::Dime));
    println!("{:?}", value_in_cents(Coin::Quarter(UsState::Alabama)));
    println!("{:?}", value_in_cents(Coin::Quarter(UsState::Alaska)))
}
Some特殊枚举成员

标准的match写法

fn main() {
    let integer_ = Some(4u8);    // Some是核心库中的范型枚举
    match integer_ {
        Some(4) => println!("four"),
        _ => println!("unknown"),     // _也是核心库中的特殊枚举(意指: 其他)
    }
}

if let 表达式是一个match的一个缩写语法糖

fn main() {
    let integer_ = Some(4u8);
    if let Some(4) = integer_ {
        println!("four");
    }
}

if let ... else ... 表达式

fn main() {
    let integer_ = Some(4u8);
    if let Some(6) = integer_ {    // 这种语法糖简化了代码却可能会带来一定的风险.
        println!("four")                // 需开发人员自己权衡.
    } else {
        println!("unknown")
    }
}

 
 

本文转载自:http://www.jianshu.com/p/285a33fd1a1f

共有 人打赏支持
AllenOR灵感
粉丝 10
博文 2139
码字总数 82983
作品 0
程序员
灵犀云语法编写指南

灵犀云智能语音平台提供语法识别功能,以下简单介绍开发者可以如何进行语法编写: ABNF语法编写指南:适用于在线语法识别 使用abnf语法文件时,需要进行语法文件的上传,语法文件可按照编写指...

iherro
2015/11/27
72
0
在VS8里面 fatal error C1083: 无法打开包括文件:“iostream.h”: No such file or directory

fatal error C1083: 无法打开包括文件:: No such file or directory 把#include 改成 #include using namespace std; 后 出现这样的错误 d:program filesmicrosoft visual studio 9.0vcincl......

hujiayi6022
2011/10/28
22.9K
5
Scrapy_命令行工具

全局命令: startproject: 语法: scrapy startproject <project_name>; 在 projectname 文件夹下创建一个名为 projectname 的Scrapy项目。 settings: 语法: scrapy settings [options] 获取S......

sidiansh
2016/04/09
13
0
Firefox和IE之间7个JavaScript的差异

尽管 JavaScript 历史上使用冗长而令人生厌的代码块来标的特定浏览器的时期已经结束了,但是偶尔使用一些简单的代码块和对象检测来确保一些代码在用户机器上正常工作依然是必要的。 这篇文章...

asurann
2010/01/26
0
0
nodejs中art-template模板语法冲突解决方案

art-template的github地址:https://github.com/aui/art-template 前端开发中,有非常多的模板引擎第三方框架,其中art-template属于写的比较好的一个,一般的模板引擎第三方都会支持一到两种...

u013263917
2017/11/05
0
0
redis系列(二)- 语法与命令

redis系列文章: redis系列(一)- 安装与启动 redis系列(二)- 语法与命令 一、简述 Redis支持的键值类型有:String字符类型、map散列类型、list列表类型、set集合类型、sortedset有序集合...

CSDN_LQR
2017/09/27
0
0
redis系列(二)- 语法与命令

redis系列文章: redis系列(一)- 安装与启动 redis系列(二)- 语法与命令 一、简述 Redis支持的键值类型有:String字符类型、map散列类型、list列表类型、set集合类型、sortedset有序集合...

CSDN_LQR
2017/09/27
0
0
MarkDown模板

用掘金-Markdown 编辑器写文章 欢迎使用 掘金-Markdown 编辑器撰写技术文章,只专注于内容和技术,不再费心排版的问题。这是一份简要的 Markdown 引导指南,希望可以帮助您顺利的开始使用 ...

我又不是架构师
2017/11/16
0
0
jQuery HTML操作学习笔记

学习资料 jQuery教程 获取 1.获取、设置元素的内容 1.1获取或设置目标元素的文本内容 语法 $(selector).text(); 获取元素文本内容$(selector).text(content);设置元素的文本内容$(selector)...

inw3cschool
2017/04/24
0
0
php常用40个代码片段

在编写代码的时候有个神奇的工具总是好的!下面这里收集了 40+ PHP 代码片段,可以帮助你开发 PHP 项目。 这些 PHP 片段对于 PHP 初学者也非常有帮助,非常容易学习,让我们开始学习吧~ 1....

我心中有猛狗
01/30
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

Android LogUtil 日志优化 调试的时候打印 点击跳转

打印日志的时候,可以点击跳转 LogUtil.java public class LogUtil { private static boolean IS_DEBUG = BuildConfig.DEBUG; public static void i(String tag, String message) {......

Jay_kyzg
15分钟前
0
0
人工智能你必须掌握的32个算法(二)归并排序算法

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子...

木头释然
18分钟前
0
0
第十四章NFS服务搭建与配置

14.1 NFS介绍 NFS介绍 NFS是Network File System的缩写;这个文件系统是基于网路层面,通过网络层面实现数据同步 NFS最早由Sun公司开发,分2,3,4三个版本,2和3由Sun起草开发,4.0开始Netap...

Linux学习笔记
41分钟前
1
0
流利阅读笔记27-20180716待学习

生了娃照样能打,两位母亲温网会师 Lala 2018-07-16 1.今日导读 现今在生儿育女后回归事业的母亲们已经非常多见,但是很少有人想到,以高强度运动与竞争激烈为特色的竞技体育项目也会有 work...

aibinxiao
42分钟前
5
0
Guava 源码分析(Cache 原理【二阶段】)

前言 在上文「Guava 源码分析(Cache 原理)」中分析了 Guava Cache 的相关原理。 文末提到了回收机制、移除时间通知等内容,许多朋友也挺感兴趣,这次就这两个内容再来分析分析。 在开始之前...

crossoverJie
54分钟前
0
0
OSChina 周一乱弹 —— 如果是你喜欢的女同学找你借钱

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @guanglun :分享Michael Learns To Rock的单曲《Fairy Tale》 《Fairy Tale》- Michael Learns To Rock 手机党少年们想听歌,请使劲儿戳(这...

小小编辑
今天
669
19
NNS域名系统之域名竞拍

0x00 前言 其实在官方文档中已经对域名竞拍的过程有详细的描述,感兴趣的可以移步http://doc.neons.name/zh_CN/latest/nns_protocol.html#id30 此处查阅。 我这里主要对轻钱包开发中会用到的...

暖冰
今天
0
0
32.filter表案例 nat表应用 (iptables)

10.15 iptables filter表案例 10.16/10.17/10.18 iptables nat表应用 10.15 iptables filter表案例: ~1. 写一个具体的iptables小案例,需求是把80端口、22端口、21 端口放行。但是,22端口我...

王鑫linux
今天
0
0
shell中的函数&shell中的数组&告警系统需求分析

20.16/20.17 shell中的函数 20.18 shell中的数组 20.19 告警系统需求分析

影夜Linux
今天
0
0
Linux网络基础、Linux防火墙

Linux网络基础 ip addr 命令 :查看网口信息 ifconfig命令:查看网口信息,要比ip addr更明了一些 centos 7默认没安装ifconfig命令,可以使用yum install -y net-tools命令来安装。 ifconfig...

李超小牛子
今天
1
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部