Rust vs Go:常用语法对比(二)
21. Swap values
交换变量a和b的值
a, b = b, a
package main
import "fmt"
func main() {
a := 3
b := 10
a, b = b, a
fmt.Println(a)
fmt.Println(b)
}
10
3
fn main() {
let a = 3;
let b = 10;
let (a, b) = (b, a);
println!("a: {a}, b: {b}", a=a, b=b);
}
输出
a: 10, b: 3
or
fn main() {
let (a, b) = (12, 42);
println!("a = {}, b = {}", a, b);
let (a, b) = (b, a);
println!("a = {}, b = {}", a, b);
}
输出
a = 12, b = 42
a = 42, b = 12
22. Convert string to integer
将字符串转换为整型
import "strconv"
i, err := strconv.Atoi(s)
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
// create a string
s := "123"
fmt.Println(s)
fmt.Println("type:", reflect.TypeOf(s))
// convert string to int
i, err := strconv.Atoi(s)
if err != nil {
panic(err)
}
fmt.Println(i)
fmt.Println("type:", reflect.TypeOf(i))
}
123
type: string
123
type: int
or
import "strconv"
i, err := strconv.ParseInt(s, 10, 0)
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
s := "123"
fmt.Println("s is", reflect.TypeOf(s), s)
i, err := strconv.ParseInt(s, 10, 0)
if err != nil {
panic(err)
}
fmt.Println("i is", reflect.TypeOf(i), i)
}
s is string 123
i is int64 123
fn main() {
// This prints 123
let mut s = "123";
let mut i = s.parse::<i32>().unwrap();
println!("{:?}", i);
// This panics
s = "12u3";
i = s.parse::<i32>().unwrap();
println!("{:?}", i);
}
输出
123
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }', src/libcore/result.rs:860
note: Run with `RUST_BACKTRACE=1` for a backtrace.
or
fn main() {
let mut s = "123";
let mut i: i32 = s.parse().unwrap_or(0);
println!("{:?}", i);
s = "12u3";
i = s.parse().unwrap_or(0);
println!("{:?}", i);
}
输出
123
0
or
fn main() {
let mut s = "123";
let mut i = match s.parse::<i32>() {
Ok(i) => i,
Err(_e) => -1,
};
println!("{:?}", i);
s = "12u3";
i = match s.parse::<i32>() {
Ok(i) => i,
Err(_e) => -1,
};
println!("{:?}", i);
}
输出
123
-1
23. Convert real number to string with 2 decimal places
Given a real number x, create its string representation s with 2 decimal digits following the dot.
给定一个实数，小数点后保留两位小数
package main
import "fmt"
func main() {
x := 3.14159
s := fmt.Sprintf("%.2f", x)
fmt.Println(s)
}
输出
3.14
fn main() {
let x = 42.1337;
let s = format!("{:.2}", x);
println!("{}", s);
}
输出
42.13
24. Assign to string the japanese word ネコ
Declare a new string s and initialize it with the literal value "ネコ" (which means "cat" in japanese)
声明一个新的字符串s，并用文字值“ネコ”初始化它(在日语中是“cat”的意思)
package main
import "fmt"
func main() {
s := "ネコ"
fmt.Println(s)
}
fn main() {
let s = "ネコ";
println!("{}", s);
}
25. Send a value to another thread
Share the string value "Alan" with an existing running process which will then display "Hello, Alan"
将字符串值“Alan”与现有的正在运行的进程共享，该进程将显示“你好，Alan”
ch <- "Alan"
package main
import (
"fmt"
"time"
)
func main() {
ch := make(chan string)
go func() {
v := <-ch
fmt.Printf("Hello, %v\n", v)
}()
ch <- "Alan"
// Make sure the non-main goroutine had the chance to finish.
time.Sleep(time.Second)
}
Hello, Alan
The receiver goroutine blocks reading the string channel ch. The current goroutine sends the value to ch. A goroutine is like a thread, but more lightweight.
use std::thread;
use std::sync::mpsc::channel;
fn main() {
let (send, recv) = channel();
let handle = thread::spawn(move || loop {
let msg = recv.recv().unwrap();
println!("Hello, {:?}", msg);
});
send.send("Alan").unwrap();
handle.join().unwrap();
}
输出 Hello, "Alan"
26. Create a 2-dimensional array
Declare and initialize a matrix x having m rows and n columns, containing real numbers.
创建一个二维数组
声明并初始化一个有m行n列的矩阵x，包含实数。
const m, n = 3, 4
var x [m][n]float64
package main
import "fmt"
func main() {
const m, n = 3, 4
var x [m][n]float64
x[1][2] = 8
fmt.Println(x)
}
[[0 0 0 0] [0 0 8 0] [0 0 0 0]]
or
package main
import "fmt"
func main() {
x := make2D(2, 3)
x[1][1] = 8
fmt.Println(x)
}
func make2D(m, n int) [][]float64 {
buf := make([]float64, m*n)
x := make([][]float64, m)
for i := range x {
x[i] = buf[:n:n]
buf = buf[n:]
}
return x
}
[[0 0 0] [0 8 0]]
fn main() {
const M: usize = 4;
const N: usize = 6;
let x = vec![vec![0.0f64; N]; M];
println!("{:#?}", x);
}
输出
[
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
]
fn main() {
const M: usize = 3;
const N: usize = 4;
let mut x = [[0.0; N] ; M];
x[1][3] = 5.0;
println!("{:#?}", x);
}
输出
[
[
0.0,
0.0,
0.0,
0.0,
],
[
0.0,
0.0,
0.0,
5.0,
],
[
0.0,
0.0,
0.0,
0.0,
],
]
27. Create a 3-dimensional array
Declare and initialize a 3D array x, having dimensions boundaries m, n, p, and containing real numbers.
创建一个三维数组
声明并初始化一个三维数组x，它有m，n，p维边界，并且包含实数。
const m, n, p = 2, 2, 3
var x [m][n][p]float64
package main
import "fmt"
func main() {
const m, n, p = 2, 2, 3
var x [m][n][p]float64
x[1][0][2] = 9
// Value of x
fmt.Println(x)
// Type of x
fmt.Printf("%T", x)
}
[[[0 0 0] [0 0 0]] [[0 0 9] [0 0 0]]]
[2][2][3]float64
or
func make3D(m, n, p int) [][][]float64 {
buf := make([]float64, m*n*p)
x := make([][][]float64, m)
for i := range x {
x[i] = make([][]float64, n)
for j := range x[i] {
x[i][j] = buf[:p:p]
buf = buf[p:]
}
}
return x
}
package main
import "fmt"
func main() {
x := make3D(2, 2, 3)
x[1][0][2] = 9
fmt.Println(x)
}
func make3D(m, n, p int) [][][]float64 {
buf := make([]float64, m*n*p)
x := make([][][]float64, m)
for i := range x {
x[i] = make([][]float64, n)
for j := range x[i] {
x[i][j] = buf[:p:p]
buf = buf[p:]
}
}
return x
}
[[[0 0 0] [0 0 0]] [[0 0 9] [0 0 0]]]
fn main() {
let m = 4;
let n = 6;
let p = 2;
let x = vec![vec![vec![0.0f64; p]; n]; m];
println!("{:#?}", x);
}
输出
[
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
]
fn main() {
const M: usize = 4;
const N: usize = 6;
const P: usize = 2;
let x = [[[0.0f64; P]; N]; M];
println!("{:#?}", x);
}
输出
[
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
[
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
[
0.0,
0.0,
],
],
]
28. Sort by a property
Sort elements of array-like collection items in ascending order of x.p, where p is a field of the type Item of the objects in items.
按x->p的升序对类似数组的集合项的元素进行排序，其中p是项中对象的项类型的字段。
package main
import "fmt"
import "sort"
type Item struct {
label string
p int
lang string
}
type ItemPSorter []Item
func (s ItemPSorter) Len() int { return len(s) }
func (s ItemPSorter) Less(i, j int) bool { return s[i].p < s[j].p }
func (s ItemPSorter) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func sortItems(items []Item) {
sorter := ItemPSorter(items)
sort.Sort(sorter)
}
func main() {
items := []Item{
{"twelve", 12, "english"},
{"six", 6, "english"},
{"eleven", 11, "english"},
{"zero", 0, "english"},
{"two", 2, "english"},
}
fmt.Println("Unsorted: ", items)
sortItems(items)
fmt.Println("Sorted: ", items)
}
Unsorted: [{twelve 12 english} {six 6 english} {eleven 11 english} {zero 0 english} {two 2 english}]
Sorted: [{zero 0 english} {two 2 english} {six 6 english} {eleven 11 english} {twelve 12 english}]
or
package main
import "fmt"
import "sort"
type Item struct {
label string
p int
lang string
}
func main() {
items := []Item{
{"twelve", 12, "english"},
{"six", 6, "english"},
{"eleven", 11, "english"},
{"zero", 0, "english"},
{"two", 2, "english"},
}
fmt.Println("Unsorted: ", items)
less := func(i, j int) bool {
return items[i].p < items[j].p
}
sort.Slice(items, less)
fmt.Println("Sorted: ", items)
}
Unsorted: [{twelve 12 english} {six 6 english} {eleven 11 english} {zero 0 english} {two 2 english}]
Sorted: [{zero 0 english} {two 2 english} {six 6 english} {eleven 11 english} {twelve 12 english}]
#[derive(Debug)]
struct Foo {
p: i32,
}
fn main() {
let mut items = vec![Foo { p: 3 }, Foo { p: 1 }, Foo { p: 2 }, Foo { p: 4 }];
items.sort_by(|a, b| a.p.cmp(&b.p));
println!("{:?}", items);
}
输出
[Foo { p: 1 }, Foo { p: 2 }, Foo { p: 3 }, Foo { p: 4 }]
or
#[derive(Debug)]
struct Foo {
p: i32,
}
fn main() {
let mut items = vec![Foo { p: 3 }, Foo { p: 1 }, Foo { p: 2 }, Foo { p: 4 }];
items.sort_by_key(|x| x.p);
println!("{:?}", items);
}
输出
[Foo { p: 1 }, Foo { p: 2 }, Foo { p: 3 }, Foo { p: 4 }]
29. Remove item from list, by its index
Remove i-th item from list items. This will alter the original list or return a new list, depending on which is more idiomatic. Note that in most languages, the smallest valid value for i is 0.
从列表项中删除第I项。 这将改变原来的列表或返回一个新的列表，这取决于哪个更习惯。 请注意，在大多数语言中，I的最小有效值是0。
package main
import (
"fmt"
)
func main() {
items := []string{"a", "b", "c", "d", "e", "f"}
fmt.Println(items)
i := 2
items = append(items[:i], items[i+1:]...)
fmt.Println(items)
}
[a b c d e f]
[a b d e f]
or
copy(items[i:], items[i+1:])
items[len(items)-1] = nil
items = items[:len(items)-1]
fn main() {
let mut v = vec![1, 2, 3];
assert_eq!(v.remove(1), 2);
assert_eq!(v, [1, 3]);
}
30. Parallelize execution of 1000 independent tasks
Launch the concurrent execution of procedure f with parameter i from 1 to 1000. Tasks are independent and f(i) doesn't return any value. Tasks need not run all at the same time, so you may use a pool.
用参数I从1到1000启动程序f的并发执行。 任务是独立的，f(i)不返回值。 任务不需要同时运行，所以可以使用pools
import "sync"
wg := sync.WaitGroup{}
wg.Add(1000)
for i := 1; i <= 1000; i++ {
go func(j int) {
f(j)
wg.Done()
}(i)
}
wg.Wait()
package main
import (
"fmt"
"math/rand"
"time"
)
func f(i int) {
d := rand.Int() % 10000
time.Sleep(time.Duration(d))
fmt.Printf("Hello %v\n", i)
}
func main() {
for i := 1; i <= 1000; i++ {
go f(i)
}
time.Sleep(4 * time.Second)
}
use std::thread;
fn main() {
let threads: Vec<_> = (0..1000).map(|i| thread::spawn(move || f(i))).collect();
for thread in threads {
thread.join();
}
}
fn f(i: i32) {
println!("{}", i);
}
or
extern crate rayon;
use rayon::prelude::*;
fn main() {
(0..1000).into_par_iter().for_each(f);
}
fn f(i: i32) {
println!("{}", i);
}
31. Recursive factorial (simple)
Create recursive function f which returns the factorial of non-negative integer i, calculated from f(i-1)
创建递归函数f，该函数返回从f(i-1)计算的非负整数I的阶乘
func f(i int) int {
if i == 0 {
return 1
}
return i * f(i-1)
}
package main
import (
"fmt"
)
func f(i int) int {
if i == 0 {
return 1
}
return i * f(i-1)
}
func main() {
for i := 0; i <= 10; i++ {
fmt.Printf("f(%d) = %d\n", i, f(i))
}
}
输出
f(0) = 1
f(1) = 1
f(2) = 2
f(3) = 6
f(4) = 24
f(5) = 120
f(6) = 720
f(7) = 5040
f(8) = 40320
f(9) = 362880
f(10) = 3628800
fn f(n: u32) -> u32 {
if n < 2 {
1
} else {
n * f(n - 1)
}
}
fn main() {
println!("{}", f(4 as u32));
}
输出
24
or
fn factorial(num: u64) -> u64 {
match num {
0 | 1=> 1,
_ => factorial(num - 1) * num,
}
}
fn main (){
println!("{}", factorial(0));
println!("{}", factorial(1));
println!("{}", factorial(2));
println!("{}", factorial(3));
println!("{}", factorial(4));
println!("{}", factorial(5));
}
输出
1
1
2
6
24
120
32. Integer exponentiation by squaring
Create function exp which calculates (fast) the value x power n. x and n are non-negative integers.
创建函数exp，计算(快速)x次方n的值。 x和n是非负整数。
package main
import "fmt"
func exp(x, n int) int {
switch {
case n == 0:
return 1
case n == 1:
return x
case n%2 == 0:
return exp(x*x, n/2)
default:
return x * exp(x*x, (n-1)/2)
}
}
func main() {
fmt.Println(exp(3, 5))
}
输出
243
fn exp(x: u64, n: u64) -> u64 {
match n {
0 => 1,
1 => x,
i if i % 2 == 0 => exp(x * x, n / 2),
_ => x * exp(x * x, (n - 1) / 2),
}
}
fn main() {
let x = 16;
let n = 4;
println!("{}", exp(x, n));
}
输出
65536
33. Atomically read and update variable
Assign variable x the new value f(x), making sure that no other thread may modify x between the read and the write.
为变量x分配新值f(x)，确保在读和写之间没有其他线程可以修改x。
package main
import (
"fmt"
"sync"
)
func main() {
var lock sync.RWMutex
x := 3
lock.Lock()
x = f(x)
lock.Unlock()
fmt.Println(x)
}
func f(i int) int {
return 2 * i
}
6
use std::sync::Mutex;
fn f(x: i32) -> i32 {
x + 1
}
fn main() {
let x = Mutex::new(0);
let mut x = x.lock().unwrap();
*x = f(*x);
println!("{:?}", *x);
}
输出
1
34. Create a set of objects
Declare and initialize a set x containing objects of type T.
声明并初始化一个包含t类型对象的集合x。
x := make(map[T]bool)
package main
import "fmt"
type T string
func main() {
// declare a Set (implemented as a map)
x := make(map[T]bool)
// add some elements
x["A"] = true
x["B"] = true
x["B"] = true
x["C"] = true
x["D"] = true
// remove an element
delete(x, "C")
for t, _ := range x {
fmt.Printf("x contains element %v \n", t)
}
}
x contains element D
x contains element A
x contains element B
or
x := make(map[T]struct{})
package main
import "fmt"
type T string
func main() {
// declare a Set (implemented as a map)
x := make(map[T]struct{})
// add some elements
x["A"] = struct{}{}
x["B"] = struct{}{}
x["B"] = struct{}{}
x["C"] = struct{}{}
x["D"] = struct{}{}
// remove an element
delete(x, "C")
for t, _ := range x {
fmt.Printf("x contains element %v \n", t)
}
}
x contains element B
x contains element D
x contains element A
use std::collections::HashSet;
fn main() {
let mut m = HashSet::new();
m.insert("a");
m.insert("b");
println!("{:?}", m);
}
输出
{"a", "b"}
35. First-class function : compose
Implement a function compose (A -> C) with parameters f (A -> B) and g (B -> C), which returns composition function g ∘ f
用参数f (A -> B)和g (B -> C)实现一个函数compose (A -> C)，返回composition函数g ∘ f
package main
import "fmt"
import "strconv"
func compose(f func(A) B, g func(B) C) func(A) C {
return func(x A) C {
return g(f(x))
}
}
func main() {
squareFromStr := compose(str2int, square)
fmt.Println(squareFromStr("12"))
}
type A string
type B int
type C int
func str2int(a A) B {
b, _ := strconv.ParseInt(string(a), 10, 32)
return B(b)
}
func square(b B) C {
return C(b * b)
}
144
fn compose<'a, A, B, C, G, F>(f: F, g: G) -> Box<Fn(A) -> C + 'a>
where F: 'a + Fn(A) -> B, G: 'a + Fn(B) -> C
{
Box::new(move |x| g(f(x)))
}
or
fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
move |x| g(f(x))
}
fn main() {
let f = |x: u32| (x * 2) as i32;
let g = |x: i32| (x + 1) as f32;
let c = compose(f, g);
println!("{}", c(2));
}
输出
5
36. First-class function : generic composition
Implement a function compose which returns composition function g ∘ f for any functions f and g having exactly 1 parameter.
实现一个函数组合，该函数组合为任何恰好有1个参数的函数f和g返回组合函数g ∘ f。
package main
import "fmt"
func composeIntFuncs(f func(int) int, g func(int) int) func(int) int {
return func(x int) int {
return g(f(x))
}
}
func main() {
double := func(x int) int {
return 2 * x
}
addTwo := func(x int) int {
return x + 2
}
h := composeIntFuncs(double, addTwo)
for i := 0; i < 10; i++ {
fmt.Println(i, h(i), addTwo(double(i)))
}
}
0 2 2
1 4 4
2 6 6
3 8 8
4 10 10
5 12 12
6 14 14
7 16 16
8 18 18
9 20 20
fn compose<'a, A, B, C, G, F>(f: F, g: G) -> Box<Fn(A) -> C + 'a>
where F: 'a + Fn(A) -> B, G: 'a + Fn(B) -> C
{
Box::new(move |x| g(f(x)))
}
or
fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
move |x| g(f(x))
}
fn main() {
let f = |x: u32| (x * 2) as i32;
let g = |x: i32| (x + 1) as f32;
let c = compose(f, g);
println!("{}", c(2));
}
输出
5
37. Currying
Transform a function that takes multiple arguments into a function for which some of the arguments are preset.
将一个接受多个参数的函数转换为一个预设了某些参数的函数。
package main
import (
"fmt"
"time"
)
type Company string
type Employee struct {
FirstName string
LastName string
}
func (e *Employee) String() string {
return "<" + e.FirstName + " " + e.LastName + ">"
}
type Payroll struct {
Company Company
Boss *Employee
Employee *Employee
StartDate time.Time
EndDate time.Time
Amount int
}
// Creates a blank payroll for a specific employee with specific boss in specific company
type PayFactory func(Company, *Employee, *Employee) Payroll
// Creates a blank payroll for a specific employee
type CustomPayFactory func(*Employee) Payroll
func CurryPayFactory(pf PayFactory, company Company, boss *Employee) CustomPayFactory {
return func(e *Employee) Payroll {
return pf(company, boss, e)
}
}
func NewPay(company Company, boss *Employee, employee *Employee) Payroll {
return Payroll{
Company: company,
Boss: boss,
Employee: employee,
}
}
func main() {
me := Employee{"Jack", "Power"}
// I happen to be head of the HR department of Richissim Inc.
var myLittlePayFactory CustomPayFactory = CurryPayFactory(NewPay, "Richissim", &me)
fmt.Println(myLittlePayFactory(&Employee{"Jean", "Dupont"}))
fmt.Println(myLittlePayFactory(&Employee{"Antoine", "Pol"}))
}
{Richissim <Jack Power> <Jean Dupont> 0001-01-01 00:00:00 +0000 UTC 0001-01-01 00:00:00 +0000 UTC 0}
{Richissim <Jack Power> <Antoine Pol> 0001-01-01 00:00:00 +0000 UTC 0001-01-01 00:00:00 +0000 UTC 0}
fn add(a: u32, b: u32) -> u32 {
a + b
}
fn main() {
let add5 = move |x| add(5, x);
let y = add5(12);
println!("{}", y);
}
输出
17
38. Extract a substring
Find substring t consisting in characters i (included) to j (excluded) of string s. Character indices start at 0 unless specified otherwise. Make sure that multibyte characters are properly handled.
查找由字符串s的字符I(包括)到j(不包括)组成的子字符串t。 除非另有说明，字符索引从0开始。 确保正确处理多字节字符。
package main
import "fmt"
func main() {
s := "hello, utf-8 문자들"
i, j := 7, 15
t := string([]rune(s)[i:j])
fmt.Println(t)
}
utf-8 문자
extern crate unicode_segmentation;
use unicode_segmentation::UnicodeSegmentation;
fn main() {
let s = "Lorem Ipsüm Dolor";
let (i, j) = (6, 11);
let t = s.graphemes(true).skip(i).take(j - i).collect::<String>();
println!("{}", t);
}
输出
Ipsüm
or
use substring::Substring;
let t = s.substring(i, j);
39. Check if string contains a word
Set boolean ok to true if string word is contained in string s as a substring, or to false otherwise.
如果字符串单词作为子字符串包含在字符串s中，则将布尔ok设置为true，否则设置为false。
package main
import (
"fmt"
"strings"
)
func main() {
s := "Let's dance the macarena"
word := "dance"
ok := strings.Contains(s, word)
fmt.Println(ok)
word = "car"
ok = strings.Contains(s, word)
fmt.Println(ok)
word = "duck"
ok = strings.Contains(s, word)
fmt.Println(ok)
}
true
true
false
fn main() {
let s = "Let's dance the macarena";
let word = "dance";
let ok = s.contains(word);
println!("{}", ok);
let word = "car";
let ok = s.contains(word);
println!("{}", ok);
let word = "duck";
let ok = s.contains(word);
println!("{}", ok);
}
输出
true
true
false
本文由 mdnice 多平台发布
相关文章：
)
Rust vs Go:常用语法对比(二)
21. Swap values 交换变量a和b的值 a, b b, a package mainimport "fmt"func main() { a : 3 b : 10 a, b b, a fmt.Println(a) fmt.Println(b)} 103 fn main() { let a 3; let b 10; let (a, b) (b, a); println!("a: {a}, b: {b}", aa,…...
对于Vue3的一些思考
看完 Vue Hooks: 让Vue开发更简单与高效 - 掘金 一些小心得 vue3： 组合式API（是利用架构，强制达到拆分目的） 达到解耦的目的。对于vue3来说 每个模块的每个逻辑都是 一个一个独立的方法。通过 方法方法整体业务 代码风格&#…...
Bean的生命周期 - spring
前言 本篇介绍了Bean的生命周期，认识PostConstruct注释，PreDestroy注释，如有错误，请在评论区指正，让我们一起交流，共同进步！ 文章目录 前言1. spring生命周期2. Bean的生命周期3. 为什么先设置…...
入门Linux基本指令(2)
这篇文章主要提供一些对文件操作的Linux基本指令，希望对大家有所帮助，三连支持！ 目录 cp指令(复制) mv指令(剪切) nano指令 cat指令(打印文件内容) > 输出重定向 >> 追加重定向 < 输入重定向 more指令 less指令(推荐) …...
【C++】【自用】选择题 刷题总结
文章目录 【类和对象】1. 构造、拷贝构造的调用2. 静态成员变量3. 初始化列表4. 成员函数：运算符重载5. 友元函数、友元类55. 特殊类设计 【细节题】1. 构造 析构 new \ deletet、new[] \ delete[] 【类和对象】 1. 构造、拷贝构造的调用 #include using namespace…...
SkyWalking链路追踪-Collector（收集器）
Collector（收集器） SkyWalking的Collector（收集器）是SkyWalking链路追踪的核心组件之一。它负责接收来自各个Agent的追踪数据，并将其存储到数据存储器（如数据库）中。具体来说，Colle…...
typescript自动编译文件实时更新
npm install -g typescripttsc --init 生成tsconfig.json配置文件 tsc -w 在监听模式下运行，当文件发生改变的时候自动编译...
qt6.5 download for kali/ubuntu ,windows (以及配置选项选择)
download and sign in qt官网 sign in onlion Install 1 2 3 4 5...
【JS 原型链】
JavaScript 原型链是一个重要的概念，它是 JavaScript 语言实现面向对象编程的核心。在 JavaScript 中，每个对象都有一个与之关联的原型，并且该对象继承了原型中的属性和方法。这些原型组成了一个原型链，可以通过该链追溯到顶层的 …...
harmonyOS 开发之UI开发（ArkTS声明式开发范式）概述
UI开发（ArkTS声明式开发范式）概述 基于ArkTS的声明式开发范式的方舟开发框架是一套开发极简、高性能、支持跨设备的UI开发框架，提供了构建OpenHarmony应用UI所必需的能力，主要包括： ArkTS ArkTS是UI开发语言ÿ…...
【人工智能】神经网络、M-P_神经元模型、激活函数、神经网络结构、学习网络参数、代价定义、总代价
M-P_神经元模型、激活函数、神经网络结构、学习网络参数、代价定义 文章目录 M-P_神经元模型、激活函数、神经网络结构、学习网络参数、代价定义M-P 神经元模型激活函数(Activation function)神经网络结构举例训练神经网络学习网络参数代价定义均方误差交叉熵（Cross Entropy）…...
小程序新渲染引擎 Skyline 发布正式版
为了进一步提升小程序的渲染性能和体验，我们推出了一套新渲染引擎 Skyline，现在，跟随着基础库 3.0.0 发布 Skyline 正式版。 我们知道，小程序一直用 WebView 来渲染界面，因其有不错的兼容性和丰富的特性，且…...
网络安全作业1
URL编码 当 URL 路径或者查询参数中，带有中文或者特殊字符的时候，就需要对 URL 进行编码（采用十六进制编码格式）。URL 编码的原则是使用安全字符去表示那些不安全的字符。 安全字符，指的是没有特殊用途或者特殊意义的…...
【NLP】视觉变压器与卷积神经网络
一、说明 本篇是 变压器因其计算效率和可扩展性而成为NLP的首选模型。在计算机视觉中，卷积神经网络（CNN）架构仍然占主导地位，但一些研究人员已经尝试将CNN与自我注意相结合。作者尝试将标准变压器直接应用于图像，发现在…...
【redis】通过配置文件简述redis的rdb和aof
redis的持久化方式有2种，rdb，即通过快照的方式将全量数据以二进制记录在磁盘中，aof，仅追加文件，将增量的写命令追加在aof文件中。在恢复的时候，rdb要更快，但是会丢失一部分数据。aof丢失数据极少…...
Cypress 上传 pdf 变空白页问题
在使用cypress 上传文件时，上传正常，但是，pdf一直空白的，翻边了资料也没找到原因。最后在一个不起眼的地方发现了问题所在。 错误的代码： cy.fixture(CBKS.pdf).as(uploadFile)cy.get(.el-upload-dragger).selectFile…...
【ArcGIS Pro二次开发】(52)：布局导出图片（批量）
在ArcGIS Pro中设定好布局后，可以直接导出为各种类型的图片。 这是很基本的功能，但是如果你的布局很多，一张一张导图就有点费劲。 之前有网友提出希望可以批量导图，要实现起来并不难，于是就做了这个工具。 一、要实现…...
Git拉取远程分支并创建本地分支
一、查看远程分支 使用如下git命令查看所有远程分支： git branch -r 查看远程和本地所有分支： git branch -a 查看本地分支： git branch 在输出结果中，前面带* 的是当前分支。 二、拉取远程分支并创建本地分支 方法一 使用…...
OSI七层模型——物理层
OSI模型的物理层位于协议栈的底部。它是 TCP/IP 模型的网络接入层的一部分。如果没有物理层，就没有网络。本模块详细介绍了连接到物理层的三种方法。 1 物理层的用途 1.1 物理连接 不管是在家连接本地打印机还是将其连接到另一国家/地区的网站上，在进…...
【NLP】使用变压器（tranformer）和自动编码器
一、说明 自然语言处理 （NLP）中，trnsformer和编码器是至关重要的概念；本篇不是探讨原理，而是讲现实中，如何调用和使用transformer以及encoder，注意。本文中有时出现“变压器”，那是transormer的同义词，在此事先声明。 二、NLP及其重要性的简要概述 NLP是人工…...
Python爬虫实战：研究feedparser库相关技术
1. 引言 1.1 研究背景与意义 在当今信息爆炸的时代，互联网上存在着海量的信息资源。RSS（Really Simple Syndication）作为一种标准化的信息聚合技术，被广泛用于网站内容的发布和订阅。通过 RSS，用户可以方便地获取网站更新的内容，而无需频繁访问各个网站。 然而，互联网…...
Linux简单的操作
ls ls 查看当前目录 ll 查看详细内容 ls -a 查看所有的内容 ls --help 查看方法文档 pwd pwd 查看当前路径 cd cd 转路径 cd .. 转上一级路径 cd 名 转换路径 …...
在WSL2的Ubuntu镜像中安装Docker
Docker官网链接: https://docs.docker.com/engine/install/ubuntu/ 1、运行以下命令卸载所有冲突的软件包： for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do sudo apt-get remove $pkg; done2、设置Docker…...
ABAP设计模式之---“简单设计原则(Simple Design)”
“Simple Design”（简单设计）是软件开发中的一个重要理念，倡导以最简单的方式实现软件功能，以确保代码清晰易懂、易维护，并在项目需求变化时能够快速适应。 其核心目标是避免复杂和过度设计，遵循“让事情保…...
动态 Web 开发技术入门篇
一、HTTP 协议核心 1.1 HTTP 基础 协议全称 ：HyperText Transfer Protocol（超文本传输协议） 默认端口 ：HTTP 使用 80 端口，HTTPS 使用 443 端口。 请求方法 ： GET ：用于获取资源，…...
DingDing机器人群消息推送
文章目录 1 新建机器人2 API文档说明3 代码编写 1 新建机器人 点击群设置 下滑到群管理的机器人，点击进入 添加机器人 选择自定义Webhook服务 点击添加 设置安全设置，详见说明文档 成功后，记录Webhook 2 API文档说明 点击设置说明 查看自…...
React核心概念：State是什么？如何用useState管理组件自己的数据？
系列回顾： 在上一篇《React入门第一步》中，我们已经成功创建并运行了第一个React项目。我们学会了用Vite初始化项目，并修改了App.jsx组件，让页面显示出我们想要的文字。但是，那个页面是“死”的，它只是静态…...
麒麟系统使用-进行.NET开发
文章目录 前言一、搭建dotnet环境1.获取相关资源2.配置dotnet 二、使用dotnet三、其他说明总结 前言 麒麟系统的内核是基于linux的，如果需要进行.NET开发，则需要安装特定的应用。由于NET Framework 是仅适用于 Windows 版本的 .NET，所以要进…...
PydanticAI快速入门示例
参考链接：https://ai.pydantic.dev/#why-use-pydanticai 示例代码 from pydantic_ai import Agent from pydantic_ai.models.openai import OpenAIModel from pydantic_ai.providers.openai import OpenAIProvider# 配置使用阿里云通义千问模型 model OpenAIMode…...
大模型——基于Docker+DeepSeek+Dify ：搭建企业级本地私有化知识库超详细教程
基于Docker+DeepSeek+Dify ：搭建企业级本地私有化知识库超详细教程 下载安装Docker Docker官网：https://www.docker.com/ 自定义Docker安装路径 Docker默认安装在C盘，大小大概2.9G，做这行最忌讳的就是安装软件全装C盘，所以我调整了下安装路径。 新建安装目录：E:\MyS…...