<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="zh_CN">
  <title>Lkhsss&apos;s blog</title>
  <subtitle>未来的我是否还是我？</subtitle>
  <link href="https://www.lkhssssss.cn/" rel="alternate" type="text/html"/>
  <link href="https://www.lkhssssss.cn/atom.xml" rel="self" type="application/atom+xml"/>
  <id>https://www.lkhssssss.cn/</id>
  <updated>2026-10-31T03:51:53.000Z</updated>
  <entry>
    <title>Go语言条件语句</title>
    <link href="https://www.lkhssssss.cn/posts/go/go-decision-making/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/go/go-decision-making/</id>
    <published>2026-10-31T03:51:53.000Z</published>
    <updated>2026-10-31T03:51:53.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<table>
<thead>
<tr>
<th>语句</th>
<th>描述</th>
</tr>
</thead>
<tbody>
<tr>
<td>if 语句</td>
<td>if 语句 由一个布尔表达式后紧跟一个或多个语句组成。</td>
</tr>
<tr>
<td>if...else 语句</td>
<td>if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。</td>
</tr>
<tr>
<td>if 嵌套语句</td>
<td>你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。</td>
</tr>
<tr>
<td>switch 语句</td>
<td>switch 语句用于基于不同条件执行不同动作。</td>
</tr>
<tr>
<td>select 语句</td>
<td>select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。</td>
</tr>
</tbody>
</table>
<h1><code>if</code> 语句</h1>
<p>语法</p>
<pre><code>if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}
</code></pre>
<h1><code>if...else</code> 语句</h1>
<p>if的plus版本，可以处理表达式为false的情况</p>
<pre><code>if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}
</code></pre>
<h1><code>switch</code></h1>
<h2>普通<code>switch</code></h2>
<p>switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。</p>
<p>switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。</p>
<p>switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。</p>
<pre><code>switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}
</code></pre>
<p>可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。</p>
<h2><code>Type Switch</code></h2>
<p>switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。</p>
<pre><code>switch x.(type){
    case type:
       statement(s);
    case type:
       statement(s);
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}
</code></pre>
<pre><code>package main

import "fmt"

func main() {
   var x interface{}

   switch i := x.(type) {
      case nil:
         fmt.Printf(" x 的类型 :%T",i)
      case int:
         fmt.Printf("x 是 int 型")
      case float64:
         fmt.Printf("x 是 float64 型")
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )
      default:
         fmt.Printf("未知型")
   }
}
</code></pre>
<h2>fallthrough</h2>
<p>使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。</p>
<pre><code>package main

import "fmt"

func main() {

    switch {
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}
</code></pre>
<p>结果</p>
<pre><code>2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Go语言运算符</title>
    <link href="https://www.lkhssssss.cn/posts/go/go-operators/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/go/go-operators/</id>
    <published>2026-10-31T03:35:54.000Z</published>
    <updated>2026-10-31T03:35:54.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h1>运算符总览</h1>
<h2>算术运算符</h2>
<p>假定 A 值为 10，B 值为 20。</p>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>实例</th>
</tr>
</thead>
<tbody>
<tr>
<td>+</td>
<td>相加</td>
<td>A + B 输出结果 30</td>
</tr>
<tr>
<td>-</td>
<td>相减</td>
<td>A - B 输出结果 -10</td>
</tr>
<tr>
<td>*</td>
<td>相乘</td>
<td>A * B 输出结果 200</td>
</tr>
<tr>
<td>/</td>
<td>相除</td>
<td>B / A 输出结果 2</td>
</tr>
<tr>
<td>%</td>
<td>求余</td>
<td>B % A 输出结果 0</td>
</tr>
<tr>
<td>++</td>
<td>自增</td>
<td>A++ 输出结果 11</td>
</tr>
<tr>
<td>--</td>
<td>自减</td>
<td>A-- 输出结果 9</td>
</tr>
</tbody>
</table>
<h2>关系运算符</h2>
<p>假定 A 值为 10，B 值为 20。</p>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>实例</th>
</tr>
</thead>
<tbody>
<tr>
<td>==</td>
<td>检查两个值是否相等，如果相等返回 True 否则返回 False。</td>
<td>(A == B) 为 False</td>
</tr>
<tr>
<td>!=</td>
<td>检查两个值是否不相等，如果不相等返回 True 否则返回 False。</td>
<td>(A != B) 为 True</td>
</tr>
<tr>
<td>&gt;</td>
<td>检查左边值是否大于右边值，如果是返回 True 否则返回 False。</td>
<td>(A &gt; B) 为 False</td>
</tr>
<tr>
<td>&lt;</td>
<td>检查左边值是否小于右边值，如果是返回 True 否则返回 False。</td>
<td>(A &lt; B) 为 True</td>
</tr>
<tr>
<td>&gt;=</td>
<td>检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。</td>
<td>(A &gt;= B) 为 False</td>
</tr>
<tr>
<td>&lt;=</td>
<td>检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。</td>
<td>(A &lt;= B) 为 True</td>
</tr>
</tbody>
</table>
<h2>逻辑运算符</h2>
<p>假定 A 值为 True，B 值为 False。</p>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>实例</th>
</tr>
</thead>
<tbody>
<tr>
<td>&amp;&amp;</td>
<td>逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。</td>
<td>(A &amp;&amp; B) 为 False</td>
</tr>
<tr>
<td>|</td>
<td>逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。</td>
<td>(A | B) 为 True</td>
</tr>
<tr>
<td>!</td>
<td>逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。</td>
<td></td>
</tr>
</tbody>
</table>
<h2>位运算符</h2>
<table>
<thead>
<tr>
<th>p</th>
<th>q</th>
<th>p &amp; q</th>
<th>p | q</th>
<th>p ^ q</th>
</tr>
</thead>
<tbody>
<tr>
<td>0</td>
<td>0</td>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>实例</th>
</tr>
</thead>
<tbody>
<tr>
<td>&amp;</td>
<td>按位与运算符"&amp;"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。</td>
<td>(A &amp; B) 结果为 12, 二进制为 0000 1100</td>
</tr>
<tr>
<td>|</td>
<td>按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或</td>
<td>(A | B) 结果为 61, 二进制为 0011 1101</td>
</tr>
<tr>
<td>^</td>
<td>按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。</td>
<td>(A ^ B) 结果为 49, 二进制为 0011 0001</td>
</tr>
<tr>
<td>&lt;&lt;</td>
<td>左移运算符"&lt;&lt;"是双目运算符。左移n位就是乘以2的n次方。 其功能把"&lt;&lt;"左边的运算数的各二进位全部左移若干位，由"&lt;&lt;"右边的数指定移动的位数，高位丢弃，低位补0。</td>
<td>A &lt;&lt; 2 结果为 240 ，二进制为 1111 0000</td>
</tr>
<tr>
<td>&gt;&gt;</td>
<td>右移运算符"&gt;&gt;"是双目运算符。右移n位就是除以2的n次方。 其功能是把"&gt;&gt;"左边的运算数的各二进位全部右移若干位，"&gt;&gt;"右边的数指定移动的位数。</td>
<td></td>
</tr>
</tbody>
</table>
<h2>赋值运算符</h2>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>实例</th>
</tr>
</thead>
<tbody>
<tr>
<td>=</td>
<td>简单的赋值运算符，将一个表达式的值赋给一个左值</td>
<td>C = A + B 将 A + B 表达式结果赋值给 C</td>
</tr>
<tr>
<td>+=</td>
<td>相加后再赋值</td>
<td>C += A 等于 C = C + A</td>
</tr>
<tr>
<td>-=</td>
<td>相减后再赋值</td>
<td>C -= A 等于 C = C - A</td>
</tr>
<tr>
<td>*=</td>
<td>相乘后再赋值</td>
<td>C *= A 等于 C = C * A</td>
</tr>
<tr>
<td>/=</td>
<td>相除后再赋值</td>
<td>C /= A 等于 C = C / A</td>
</tr>
<tr>
<td>%=</td>
<td>求余后再赋值</td>
<td>C %= A 等于 C = C % A</td>
</tr>
<tr>
<td>&lt;&lt;=</td>
<td>左移后赋值</td>
<td>C &lt;&lt;= 2 等于 C = C &lt;&lt; 2</td>
</tr>
<tr>
<td>&gt;&gt;=</td>
<td>右移后赋值</td>
<td>C &gt;&gt;= 2 等于 C = C &gt;&gt; 2</td>
</tr>
<tr>
<td>&amp;=</td>
<td>按位与后赋值</td>
<td>C &amp;= 2 等于 C = C &amp; 2</td>
</tr>
<tr>
<td>^=</td>
<td>按位异或后赋值</td>
<td>C ^= 2 等于 C = C ^ 2</td>
</tr>
<tr>
<td>|=</td>
<td>按位或后赋值</td>
<td>C |= 2 等于 C = C | 2</td>
</tr>
</tbody>
</table>
<h2>其他运算符</h2>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>实例</th>
</tr>
</thead>
<tbody>
<tr>
<td>&amp;</td>
<td>返回变量存储地址</td>
<td>&amp;a; 将给出变量的实际地址。</td>
</tr>
<tr>
<td>*</td>
<td>指针变量。</td>
<td></td>
</tr>
</tbody>
</table>
<h1>运算符优先级</h1>
<p>有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：</p>
<table>
<thead>
<tr>
<th>优先级</th>
<th>运算符</th>
</tr>
</thead>
<tbody>
<tr>
<td>5</td>
<td>* / % &lt;&lt; &gt;&gt; &amp; &amp;^</td>
</tr>
<tr>
<td>4</td>
<td>+ - | ^</td>
</tr>
<tr>
<td>3</td>
<td>== != &lt; &lt;= &gt; &gt;=</td>
</tr>
<tr>
<td>2</td>
<td>&amp;&amp;</td>
</tr>
<tr>
<td>1</td>
<td>|</td>
</tr>
</tbody>
</table>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Rust的Typestate思想</title>
    <link href="https://www.lkhssssss.cn/posts/rust/rust-typestate-design/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/rust/rust-typestate-design/</id>
    <published>2026-10-30T01:55:24.000Z</published>
    <updated>2026-10-30T01:55:24.000Z</updated>
    <summary>Typestate模式是Rust中一种强大的编译期状态机实现方式，它将对象的运行时状态编码进类型系统中，从而让编译器在代码运行前就帮你拒绝所有非法的状态转换。</summary>
    <content type="html"><![CDATA[<p><code>Typestate（类型状态）</code>模式是Rust中一种强大的编译期状态机实现方式，它将对象的运行时状态编码进类型系统中，从而让编译器在代码运行前就帮你拒绝所有非法的状态转换。</p>
<hr />
<h1>让非法状态“不可表示”</h1>
<p>Typestate的核心原则可以概括为三点：</p>
<ol>
<li>
<p>每个状态都是一个<strong>独立的类型</strong>：例如，一个网络连接会有 <code>Handshaking</code>、<code>Authenticated</code>、<code>Closed</code> 等不同的类型。</p>
</li>
<li>
<p>状态转换会“<strong>消耗</strong>”旧状态，“<strong>产生</strong>”新状态：转换方法会拿走旧状态的所有权（self），并返回一个新状态的实例。</p>
</li>
<li>
<p>非法操作在<strong>编译期就会失败</strong>：因为方法只定义在特定状态类型上，对错误的状态调用该方法会直接导致<strong>编译错误</strong>，而不是运行时错误。</p>
</li>
</ol>
<h1>实现</h1>
<h2>反例</h2>
<p>常规的状态都是使用<code>enum</code>的变体表示。
举个简单的例子，假设需要构建一个简单的<code>Builder</code>:</p>
<pre><code>// 此处有两种状态，一个是构造中，一个是构造完成
enum BuilderState {
    Building,
    Ready,
}
struct Data;

/// 假设此处的两个option都必须在Builder时期由用户选择
struct Builder {
    data1: Option&lt;Data&gt;,
    data2: Option&lt;Data&gt;,
    state: BuilderState,
}

impl Builder {
    fn new() -&gt; Builder {
        Self {
            data1: None,
            data2: None,
            state: BuilderState::Building,
        }
    }
    fn set_data1(&amp;mut self, d: Data) {
        self.data1 = Some(d)
    }
    fn set_data2(&amp;mut self, d: Data) {
        self.data2 = Some(Data)
    }
    /// 此处的build必须要data1和data2都有设置才能运行，但是使用if语句检查是运行时检查，失去了rust类型检查系统的优势，并且还需要额外处理错误分支
    fn build(&amp;mut self) {
        //....Do Some Thing
        if self.data1.is_some() &amp;&amp; self.data2.is_some() {
            self.state = BuilderState::Ready;
            unimplemented!()
        }
        else{
            unimplemented!()
            // 额外处理错误
        }
    }
}
</code></pre>
<p>这样是最常用的写法，状态使用<code>enum</code>方便且易于管理。但是这样就让各种检查都需要在运行时才能进行，还需要额外处理报错的情况。此时就需要使用<code>Typestate</code>模式！</p>
<h2>真正的用法</h2>
<p>还是刚刚的例子，构建一个Builder模式，这是<code>Typestate</code>模式最经典的应用场景。</p>
<p>但是不再使用<code>enum</code>表示状态，而是使用<code>struct</code>表示：</p>
<pre><code>use std::marker::PhantomData;
struct Missing;
struct Ready;

struct Data;
struct Builder&lt;S&gt; {
    data1: Option&lt;Data&gt;,
    data2: Option&lt;Data&gt;,
    _state: PhantomData&lt;S&gt;, // 零大小，仅用于类型标记
}
impl Builder&lt;(Missing, Missing)&gt; {
    fn new() -&gt; Self {
        Self {
            data1: None,
            data2: None,
            _state: PhantomData,
        }
    }
}
// data1() 只存在于「第一个字段还是 Missing」的任意状态下
impl&lt;S2&gt; Builder&lt;(Missing, S2)&gt; {
    fn data1(self, d: Data) -&gt; Builder&lt;(Ready, S2)&gt; {
        Builder {
            data1: Some(d),
            data2: self.data2,
            _state: PhantomData,
        }
    }
    /// 此处可放一些只有data2 Ready了才能做的事
    fn some_thing_only_data2_can_do(&amp;self) {}
}

// data2() 只存在于「第二个字段还是 Missing」的任意状态下
impl&lt;S1&gt; Builder&lt;(S1, Missing)&gt; {
    fn data2(self, d: Data) -&gt; Builder&lt;(S1, Ready)&gt; {
        Builder {
            data1: self.data1,
            data2: Some(d),
            _state: PhantomData,
        }
    }
    /// 此处可放一些只有data1 Ready了才能做的事
    fn some_thing_only_data1_can_do(&amp;self) {}
}

// 只有两个字段都 Ready 了，build() 才存在
impl Builder&lt;(Ready, Ready)&gt; {
    fn build(self) -&gt; (Data, Data) {
        // 类型系统已保证两个都是 Some，unwrap 不会 panic
        (self.data1.unwrap(), self.data2.unwrap())
    }
}
</code></pre>
<blockquote>
<p>[!Note]</p>
<p><code>Typestate</code> 与 Builder 模式结合，可以在编译期强制要求“必填字段”必须被设置。例如，一个 data1和data2 只有都设置了之后，才能调用 <code>.build()</code>。</p>
</blockquote>
<p>采用这种模式之后，没有正确设置的都会报错：</p>
<pre><code>let b: Builder&lt;(Missing, Missing)&gt; = Builder::new();
let b: Builder&lt;(Ready, Missing)&gt;  = b.data1(Data);
b.build(); //no method named `build` found for struct `Builder&lt;(Ready, Missing)&gt;` in the current scope the method was found for `Builder&lt;(Ready, Ready)&gt;`
</code></pre>
<p>正确设置后才能调用<code>.build()</code>:</p>
<pre><code>let b: Builder&lt;(Missing, Missing)&gt; = Builder::new();
let b: Builder&lt;(Ready, Ready)&gt; = b.data1(Data).data2(Data);
b.build(); // 没报错
</code></pre>
<p>并且<strong>消耗</strong>旧状态<strong>产生</strong>新状态刚好可以完美地使用rust的链式调用，肥肠方便^_^</p>
<h1>优缺点权衡</h1>
<h2>优势</h2>
<ul>
<li>
<p>编译期安全：将状态机不变量检查从运行时提前到编译期，消除了一整类 bug。</p>
</li>
<li>
<p>零运行时开销：状态标记（如 <code>PhantomData</code>）在编译后会被擦除，不占用内存或影响性能。</p>
</li>
<li>
<p>自文档化：类型签名本身就清晰地描述了合法的操作序列。</p>
</li>
</ul>
<h2>代价</h2>
<ul>
<li>
<p>样板代码较多：需要定义多个标记类型和独立的 impl 块。</p>
</li>
<li>
<p>对状态组合的灵活性较低：在需要动态改变状态或状态组合非常复杂时，可能不如运行时状态机灵活。</p>
</li>
</ul>
<hr />
<p>总之，<code>Typestate</code> 是 <code>Rust</code> 类型系统能力的一种深刻体现。它把对“正确性”的保证从程序员的记忆和测试用例，转移到了编译器的强制检查中。</p>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Git:约定式分支</title>
    <link href="https://www.lkhssssss.cn/posts/conventional_branch/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/conventional_branch/</id>
    <published>2026-10-26T13:16:43.000Z</published>
    <updated>2026-10-26T13:16:43.000Z</updated>
    <summary>约定式分支是指 Git 分支的结构化和标准化命名约定，旨在使分支更具可读性和可操作性。我们建议了一些您可能想要使用的分支前缀，但您也可以指定自己的命名约定。一致的命名约定使按类型识别分支变得更加容易。</summary>
    <content type="html"><![CDATA[<h1>概述</h1>
<p>约定式分支是指 Git 分支的结构化和标准化命名约定，旨在使分支更具可读性和可操作性。我们建议了一些您可能想要使用的分支前缀，但您也可以指定自己的命名约定。一致的命名约定使按类型识别分支变得更加容易。</p>
<h1>规范</h1>
<h2>分支命名前缀</h2>
<p>其结构应如下：</p>
<pre><code>&lt;type&gt;/&lt;description&gt;
</code></pre>
<h2>用途前缀</h2>
<table>
<thead>
<tr>
<th>前缀</th>
<th>简写</th>
<th>用途</th>
<th>例子</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>feature/</code></td>
<td><code>feat/</code></td>
<td>用于新功能</td>
<td><code>feature/add-login-page</code>, <code>feat/add-login-page</code></td>
</tr>
<tr>
<td><code>bugfix/</code></td>
<td><code>fix/</code></td>
<td>用于错误修复</td>
<td><code>bugfix/fix-header-bug</code>, <code>fix/header-bug</code></td>
</tr>
<tr>
<td><code>hotfix/</code></td>
<td></td>
<td>用于紧急修复</td>
<td><code>hotfix/security-patch</code></td>
</tr>
<tr>
<td><code>release/</code></td>
<td></td>
<td>用于准备发布的分支</td>
<td><code>release/v1.2.0</code></td>
</tr>
<tr>
<td><code>chore/</code></td>
<td></td>
<td>用于非代码任务，如依赖项、文档更新</td>
<td><code>chore/update-dependencies</code></td>
</tr>
</tbody>
</table>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Python@cache修饰器</title>
    <link href="https://www.lkhssssss.cn/posts/python/python-cache-decorator/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/python/python-cache-decorator/</id>
    <published>2026-10-14T14:24:08.000Z</published>
    <updated>2026-10-14T14:24:08.000Z</updated>
    <summary>神秘的函数缓存修饰器</summary>
    <content type="html"><![CDATA[<blockquote>
<p>[!NOTE]
<code>@cache</code> 是 Python 3.9+ 在 <code>functools</code> 模块中引入的装饰器，用于缓存函数的返回值（记忆化）。它是 <code>@lru_cache(maxsize=None)</code> 的简写形式。</p>
</blockquote>
<h1>基本用法</h1>
<pre><code>from functools import cache

@cache
def fibonacci(n):
    if n &lt; 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(100))  # 瞬间返回，无需重复计算
</code></pre>
<p>加上 <code>@cache</code> 后运行瞬间完成，简直快到飞起</p>
<h1>核心特征</h1>
<table>
<thead>
<tr>
<th>特性</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>缓存大小</td>
<td>无限（等价于 lru_cache(maxsize=None)）</td>
</tr>
<tr>
<td>缓存键</td>
<td>基于函数参数（必须可哈希 hashable）</td>
</tr>
<tr>
<td>线程安全</td>
<td>是</td>
</tr>
<tr>
<td>作用范围</td>
<td>每个被装饰函数独立一份缓存</td>
</tr>
</tbody>
</table>
<h1>其他用法</h1>
<pre><code>from functools import cache

@cache                          # 无限缓存，Python 3.9+
def f(x): ...

f.cache_info()                  # 查看命中统计
f.cache_clear()                 # 清空缓存
f.cache_parameters()            # 查看配置参数
</code></pre>
<h1>注意事项</h1>
<ol>
<li>
<p>参数必须可哈希</p>
</li>
<li>
<p>不要缓存有副作用或依赖外部状态的函数</p>
</li>
<li>
<p>区分 1 和 1.0（默认不区分）</p>
</li>
</ol>
<blockquote>
<p>[!NOTE]
如果需要区分类型，用 @lru_cache(typed=True)。</p>
</blockquote>
<ol>
<li>内存占用问题
@cache 无限增长，长时间运行的程序可能内存爆掉</li>
</ol>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Go语言常量声明</title>
    <link href="https://www.lkhssssss.cn/posts/go/go-constants/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/go/go-constants/</id>
    <published>2026-10-13T14:23:29.000Z</published>
    <updated>2026-10-13T14:23:29.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h1>关键字</h1>
<p>Go语言使用<code>const</code>声明常量</p>
<pre><code>const identifier [type] = value
</code></pre>
<blockquote>
<p>[!Note]</p>
<ul>
<li><code>identifier</code>：常量名称，遵循 Go 标识符命名规则（字母、数字、下划线，且不能以数字开头）。</li>
<li>同时类型名如果省略则由编译器自动推断</li>
</ul>
</blockquote>
<h1>常量组与枚举</h1>
<p>Go 语言没有枚举（enum）关键字，通常使用常量组来实现枚举效果：</p>
<pre><code>// 定义性别枚举
const (
    Unknown = 0
    Female  = 1
    Male    = 2
)
</code></pre>
<h1>内置函数在常量中的应用</h1>
<p>常量表达式中可以使用 len()、cap()、unsafe.Sizeof() 等内置函数计算表达式的值。</p>
<p>注意：常量表达式中函数必须是内置函数。</p>
<pre><code>package main
import (
    "fmt"
    "unsafe"
)
const (
    a = "abc"
    b = len(a)              // 使用 len() 获取字符串长度，结果为 3。
    c = unsafe.Sizeof(a)    // 使用 unsafe.Sizeof() 获取变量内存占用，结果为 16 字节（字符串结构体在 64 位系统上占 16 字节）。
)
func main() {
    fmt.Printf("a=%s, b=%d, c=%d\n", a, b, c)
}
</code></pre>
<h1>常量计数器</h1>
<p><code>iota</code> 是 Go 语言的特殊常量，也称为常量计数器。它可以在 const 声明块中自动生成递增的序列值。</p>
<pre><code>package main

import "fmt"

// iota 从 0 开始，每行加 1
const (
    a = iota   // 0
    b          // 1（省略值，默认使用上一行的 iota）
    c          // 2
)

func main() {
    fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c)
}
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Dart：变量声明</title>
    <link href="https://www.lkhssssss.cn/posts/flutter/dart-variables/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/flutter/dart-variables/</id>
    <published>2026-10-11T13:18:25.000Z</published>
    <updated>2026-10-11T13:18:25.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h1>关键字<code>var</code></h1>
<blockquote>
<p>[!NOTE]
特点：确定类型后无法改变</p>
<pre><code>var t = "hi world";
// 下面代码在dart中会报错，因为变量t的类型已经确定为String，
// 类型一旦确定后则不能再更改其类型。
t = 1000;
</code></pre>
</blockquote>
<h1><code>dynamic</code> 和 <code>Object</code></h1>
<p><code>Object</code> 是 Dart 所有对象的根基类，也就是说在 Dart 中所有类型都是<code>Object</code>的子类(包括Function和Null)，所以任何类型的数据都可以赋值给<code>Object</code>声明的对象。 <code>dynamic</code>与<code>Object</code>声明的变量都可以赋值任意对象，且后期可以改变赋值的类型，这和 <code>var</code> 是不同的，如：</p>
<pre><code>dynamic t;
Object x;
t = "hi world";
x = 'Hello Object';
//下面代码没有问题
t = 1000;
x = 1000;
</code></pre>
<h1>常量</h1>
<p>使用<code>final</code>和<code>const</code>来声明常量。而两者区别在于：<code>const</code> 变量是一个编译时常量（编译时直接替换为常量值），<code>final</code>变量在第一次使用时被初始化。</p>
<p>被<code>final</code>或者<code>const</code>修饰的变量，变量类型可以省略。</p>
<pre><code>//可以省略String这个类型声明
final str = "hi world";
//final String str = "hi world";
const str1 = "hi world";
//const String str1 = "hi world";
</code></pre>
<h1>空安全</h1>
<p>定义变量时我们可以指定变量是可空还是不可空</p>
<pre><code>int i = 8; //默认为不可空，必须在定义时初始化。
int? j; // 定义为可空类型，对于可空变量，我们在使用前必须判空。

// 如果我们预期变量不能为空，但在定义时不能确定其初始值，则可以加上late关键字，
// 表示会稍后初始化，但是在正式使用它之前必须得保证初始化过了，否则会报错
late int k;
k=9;
</code></pre>
<p>如果一个变量我们定义为可空类型，在某些情况下即使我们给它赋值过了，但是预处理器仍然有可能识别不出，这时我们就要显式使用<code>！</code>告诉预处理器它已经不是null了，比如：</p>
<pre><code>class Test{
  int? i;
  Function? fun;
  say(){
    if(i!=null) {
      print(i! * 8); //因为已经判过空，所以能走到这 i 必不为null，如果没有显式申明，则 IDE 会报错
    }
    if(fun!=null){
      fun!(); // 同上
    }
  }
}
</code></pre>
<p>上面中如果函数变量可空时，调用的时候可以用语法糖：</p>
<pre><code>fun?.call() // fun 不为空时则会被调用
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Go变量声明</title>
    <link href="https://www.lkhssssss.cn/posts/go/go-variables/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/go/go-variables/</id>
    <published>2026-10-10T02:23:05.000Z</published>
    <updated>2026-10-10T02:23:05.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h1>关键字</h1>
<blockquote>
<p>变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。</p>
</blockquote>
<p>Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。</p>
<p>声明变量的一般形式是使用 var 关键字：</p>
<pre><code>var identifier type
</code></pre>
<p>可以一次声明多个变量：</p>
<pre><code>var identifier1, identifier2 type
</code></pre>
<blockquote>
<p>[!NOTE]
实例：</p>
<pre><code>package main
import "fmt"
func main() {
var a string = "TEST"
fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)

}
</code></pre>
</blockquote>
<h1>变量声明</h1>
<h2>有值初始化</h2>
<p>直接使用<code>var</code>关键字初始化</p>
<pre><code>var a string = "TEST"
</code></pre>
<p>也可以不使用类型，通过值来自动推断类型</p>
<pre><code>var a = "TEST"
</code></pre>
<h2>零值初始化</h2>
<p>也可以只声明，不赋值，那么变量自动初始化为零值 <a href="%E9%9B%B6%E5%80%BC%E5%B0%B1%E6%98%AF%E5%8F%98%E9%87%8F%E6%B2%A1%E6%9C%89%E5%81%9A%E5%88%9D%E5%A7%8B%E5%8C%96%E6%97%B6%E7%B3%BB%E7%BB%9F%E9%BB%98%E8%AE%A4%E8%AE%BE%E7%BD%AE%E7%9A%84%E5%80%BC%E3%80%82">+零值</a></p>
<pre><code>// bool 零值为 false
var c bool
</code></pre>
<h2>短变量声明</h2>
<p>还有一种写法可以省略<code>var</code>关键字。</p>
<pre><code>var a = "var声明变量"
</code></pre>
<p>等价于</p>
<pre><code>a := "短变量声明"
</code></pre>
<blockquote>
<p>[!WARNING]
<code>:=</code>只能在函数内部使用，不能用于包级别</p>
</blockquote>
<blockquote>
<p>[!WARNING]
如果变量已经使用 <code>var</code> 声明过了，再使用 <code>:=</code> 声明变量，就产生编译错误</p>
</blockquote>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>windows常用系统变量整理</title>
    <link href="https://www.lkhssssss.cn/posts/windows-env/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/windows-env/</id>
    <published>2026-09-28T11:31:20.000Z</published>
    <updated>2026-09-28T11:31:20.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h1>关于Windows系统常用系统变量的整理......</h1>
<table>
<thead>
<tr>
<th>变量</th>
<th>路径</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>%ALLUSERSPROFILE%</code></td>
<td><code>C:\ProgramData</code></td>
</tr>
<tr>
<td><code>%APPDATA%</code></td>
<td><code>C:\Users\用户名\AppData\Roaming</code></td>
</tr>
<tr>
<td><code>%COMMONPROGRAMFILES%</code></td>
<td><code>C:\Program Files\Common Files</code></td>
</tr>
<tr>
<td><code>%COMMONPROGRAMFILES(x86)%</code></td>
<td><code>C:\Program Files (x86)\Common Files</code></td>
</tr>
<tr>
<td><code>%COMSPEC%</code></td>
<td><code>C:\Windows\System32\cmd.exe</code></td>
</tr>
<tr>
<td><code>%HOMEDRIVE%和%SystemDrive%</code></td>
<td><code>C:\</code></td>
</tr>
<tr>
<td><code>%HOMEPATH%</code></td>
<td><code>C:\Users\用户名</code></td>
</tr>
<tr>
<td><code>%LOCALAPPDATA%</code></td>
<td><code>C:\Users\用户名\AppData\Local</code></td>
</tr>
<tr>
<td><code>%PROGRAMDATA%</code></td>
<td><code>C:\ProgramData</code></td>
</tr>
<tr>
<td><code>%PROGRAMFILES%</code></td>
<td><code>C:\Program Files</code></td>
</tr>
<tr>
<td><code>%PROGRAMFILES(X86)%</code></td>
<td><code>C:\Program Files (x86)</code></td>
</tr>
<tr>
<td><code>%PUBLIC%</code></td>
<td><code>C:\UsersPublic</code></td>
</tr>
<tr>
<td><code>%SystemRoot%</code></td>
<td><code>C:\Windows</code></td>
</tr>
<tr>
<td><code>%TEMP%和%TMP%</code></td>
<td><code>C:\Users\用户名\AppData\LocalTemp</code></td>
</tr>
<tr>
<td><code>%USERPROFILE%</code></td>
<td><code>C:\Users\用户名</code></td>
</tr>
<tr>
<td><code>%WINDIR%</code></td>
<td><code>C:\Window</code></td>
</tr>
<tr>
<td><code>%systemroot%\Resources</code></td>
<td>Windows 主题目录 <code>C:\WINDOWS\Resources\</code></td>
</tr>
<tr>
<td><code>%systemroot%\Web\Wallpaper Windows</code></td>
<td>自带的壁纸目录 <code>C:\WINDOWS\Web\Wallpaper</code></td>
</tr>
</tbody>
</table>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>rust程序如何读取自己的版本号？</title>
    <link href="https://www.lkhssssss.cn/posts/rust/rust-read-cargo-pkg-version/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/rust/rust-read-cargo-pkg-version/</id>
    <published>2026-09-26T07:44:26.000Z</published>
    <updated>2026-09-26T07:44:26.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<p>Rust程序编译时，程序的版本号会作为<strong>环境变量</strong>注入到编译环境中，只需要读取<code>CARGO_PKG_VERSION</code>中的值即可。</p>
<p>为将版本号嵌入程序中，使用<code>env!</code>宏：</p>
<pre><code>env!("CARGO_PKG_VERSION")
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Cargo换源</title>
    <link href="https://www.lkhssssss.cn/posts/rust/rust-mirror/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/rust/rust-mirror/</id>
    <published>2024-10-13T00:15:07.000Z</published>
    <updated>2024-10-13T00:15:07.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<p>~/.cargo/config.toml</p>
<pre><code># 替换成你偏好的镜像源
#replace-with = 'tuna'
# replace-with = 'ustc'
#replace-with = 'zju'

# 源地址
[source.crates-io]
# registry = "https://github.com/rust-lang/crates.io-index"
replace-with = 'rsproxy-sparse'

#字节跳动
[source.rsproxy]
registry = "https://rsproxy.cn/crates.io-index"
[source.rsproxy-sparse]
registry = "sparse+https://rsproxy.cn/index/"
[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# 中国科学技术大学
[source.ustc]
#registry = "git://mirrors.ustc.edu.cn/crates.io-index"
registry = "sparse+https://mirrors.ustc.edu.cn/crates.io-index/"

# 浙江大学
[source.zju]
registry = "https://mirrors.zju.edu.cn/git/crates.io-index.git"


# 上海交通大学
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index"

</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Git设置代理</title>
    <link href="https://www.lkhssssss.cn/posts/git-proxy/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/git-proxy/</id>
    <published>2024-08-30T17:11:52.000Z</published>
    <updated>2024-08-30T17:11:52.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h2>设置代理</h2>
<h3>http</h3>
<pre><code>git config --global http.proxy http://ip:port
git config --global https.proxy http://ip:port
</code></pre>
<p>例如：</p>
<pre><code>git config --global http.proxy http://127.0.0.1:7890
git config --global https.proxy http://127.0.0.1:7890
</code></pre>
<h2>取消设置</h2>
<h3>http</h3>
<pre><code>git config --global --unset http.proxy
git config --global --unset https.proxy
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Rust编译体积优化</title>
    <link href="https://www.lkhssssss.cn/posts/rust/rust-compiler-optimization/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/rust/rust-compiler-optimization/</id>
    <published>2024-08-24T10:08:47.000Z</published>
    <updated>2024-08-24T10:08:47.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h2>Cargo优化</h2>
<p><code>Cargo.toml</code></p>
<pre><code>[profile.release]
#缩小编译后体积
strip = true
# strip = "debuginfo" #仅移除debug信息

lto = true #启用链接时间优化
panic = "abort" #panic时直接abort
opt-level = "z" #优化级别   1, 2, 3, "s", "z"

</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>优雅地为iced应用程序添加图标</title>
    <link href="https://www.lkhssssss.cn/posts/rust/iced-add-icon/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/rust/iced-add-icon/</id>
    <published>2024-08-21T00:15:31.000Z</published>
    <updated>2024-08-21T00:15:31.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h1>设置图标</h1>
<p>图标分为两种。</p>
<p>一种是显示在应用左上角异界任务栏上的图标。</p>
<p>一种是系统读取文件时显示的图标（本文方法仅适用于Windows）。</p>
<p>首先准备好一个符合windows规范的icon文件（本文以<code>icon.ico</code>为例），放在根目录中</p>
<h2>在iced中设置应用内和任务栏图标</h2>
<p>其他人多使用<code>icon::from_rgba()</code>方法，配合<code>image</code>库读取图片来为程序添加图标，但其实iced为大家提供了<code>image</code>feature来直接一步到位。
使用以下命令启用iced的<code>image</code>feature:</p>
<pre><code>cargo add iced -F image
</code></pre>
<p>然后直接设置一手<code>iced::window::icon::from_file_data()</code>,然后用<code>include_bytes</code>宏直接读取图片数据，然后设置<code>window</code>的设置<code>icon</code>。</p>
<blockquote>
<p>图片不能是矢量图(<code>.svg</code>)，但是位图(<code>.png</code>,<code>.jpg</code>,<code>.ico</code>....)应该都可以。
图片的位置时相对于<code>main.rs</code>文件的。所以当icon文件放在项目根目录时，相对路径应为<code>../icon.png</code>
同时``iced::window::icon<code>还有一个</code>from_file<code>方法，可以动态读取图标。而</code>from_file_data`主要是为了在编译时就硬编码好图标。</p>
</blockquote>
<p>设置代码如下：</p>
<pre><code>use iced::window::{icon, Icon};
fn main() -&gt; iced::Result {
    App::run(Settings{
        window:iced::window::Settings{
    		icon:Some(Icon::from(icon::from_file_data(include_bytes!("../icon.png"),None).unwrap())),
    		..Default::default()
		},
	..Default::default()
    	})
}
</code></pre>
<h2>设置程序文件图标</h2>
<h3>首先添加编译脚本依赖</h3>
<p>以下是<code>Cargo.toml</code>的内容</p>
<pre><code>[package]
build = "src/build.rs"
[build-dependencies]
winres = "*"
</code></pre>
<p>然后在src文件夹中添加一个叫<code>build.rs</code>文件
文件内容如下</p>
<pre><code>use winres;

fn main() {
    let mut res = winres::WindowsResource::new();
    res.set_icon("icon.ico");
    res.compile().unwrap();
}
</code></pre>
<blockquote>
<p>winres的图片相对路径是项目根目录，所以<code>icon.ico</code>即可。
还可以在<code>Cargo.toml</code>中使用<code>[package.metadata.winres]</code>来设置应用的信息。具体请看<a href="https://learn.microsoft.com/zh-cn/windows/win32/menurc/versioninfo-resource?redirectedfrom=MSDN">MSDN</a></p>
</blockquote>
<h3>最后一步！</h3>
<p>熟悉的构建环节</p>
<pre><code>cargo build -r
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Powershell历史记录清除</title>
    <link href="https://www.lkhssssss.cn/posts/powershell-history-clean/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/powershell-history-clean/</id>
    <published>2024-08-21T15:08:15.000Z</published>
    <updated>2024-08-21T15:08:15.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h2>清除Powershell所有历史记录</h2>
<pre><code>Remove-Item (Get-PSReadlineOption).HistorySavePath
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>树莓派：优雅地修改swap分区大小</title>
    <link href="https://www.lkhssssss.cn/posts/raspberry-change-swap/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/raspberry-change-swap/</id>
    <published>2024-04-14T08:53:38.000Z</published>
    <updated>2024-04-14T08:53:38.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<p>Raspberry Pi OS默认的swap分区仅为<strong>100MiB</strong>，这对于我买的<s>512G大卡</s>来说这明显太小了。这时就可以用树莓派的配置文件来优雅地修改swap分区，而不用创建swap文件或使用奇淫巧计。</p>
<h2>修改swap分区配置</h2>
<p>配置文件地址：<code>/etc/dphys-swapfile</code>
选择使用合你喜欢的方式编辑文本就行，但是要root权限。
比如：</p>
<pre><code>sudo nano /etc/dphys-swapfile
</code></pre>
<p>找到<code>CONF_SWAPSIZE</code>这一行，将后面的数字改为你想调整的大小，单位是MiB。(1GiB=1024MiB)</p>
<blockquote>
<p>经过尝试，目前修改的最大swap分区大小为4048MiB</p>
</blockquote>
<p>而<code>CONF_MAXSWAP</code>参数则用来设置最大大小，这个值应比<code>CONF_SWAPSIZE</code>大</p>
<h2>重启swap服务</h2>
<pre><code>sudo /etc/init.d/dphys-swapfile restart
</code></pre>
<p>重启完后可以使用<code>free -h</code>查看swap分区大小。</p>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Rustup换源</title>
    <link href="https://www.lkhssssss.cn/posts/rust/rustup-mirror/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/rust/rustup-mirror/</id>
    <published>2023-08-15T11:23:36.000Z</published>
    <updated>2023-08-15T11:23:36.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<p>由于rust的官方服务器在中国访问很慢，所以在安装和更新的时候经常出现下载时卡住的情况。
这时应换源处理。</p>
<h2>换源</h2>
<h3>1.添加临时环境变量</h3>
<h4>Windows</h4>
<h5>中科大镜像</h5>
<pre><code>$ENV:RUSTUP_DIST_SERVER='https://mirrors.ustc.edu.cn/rust-static'
$ENV:RUSTUP_UPDATE_ROOT='https://mirrors.ustc.edu.cn/rust-static/rustup'
</code></pre>
<pre><code>set RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static
set RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup
</code></pre>
<h5>字节跳动镜像</h5>
<pre><code>$ENV:RUSTUP_DIST_SERVER='https://rsproxy.cn'
$ENV:RUSTUP_UPDATE_ROOT='https://rsproxy.cn/rustup'
</code></pre>
<pre><code>set RUSTUP_DIST_SERVER=https://rsproxy.cn
set RUSTUP_UPDATE_ROOT=https://rsproxy.cn/rustup
</code></pre>
<h4>Linux</h4>
<h5>中科大镜像</h5>
<pre><code>export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static
export RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup
</code></pre>
<h5>字节跳动镜像</h5>
<pre><code>export RUSTUP_DIST_SERVER=https://rsproxy.cn
export RUSTUP_UPDATE_ROOT=https://rsproxy.cn/rustup
</code></pre>
<p>这两行代码将会把rust的下载和更新源更改为中科大和字节跳动的镜像服务器</p>
<h3>2.正常安装或更新Rust</h3>
<p>不关闭刚刚打开的命令行，将工作目录定位到rust安装包的位置。</p>
<p>运行：</p>
<pre><code>.\rustup-init.exe
</code></pre>
<p>或者更新</p>
<pre><code>rustup update
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>MySQL安装及部分报错解决方案</title>
    <link href="https://www.lkhssssss.cn/posts/mysql-install-solution/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/mysql-install-solution/</id>
    <published>2023-04-08T18:58:34.000Z</published>
    <updated>2023-04-08T18:58:34.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h2>1.<code>ERROR 1698 (28000): Access denied for user 'root'@'localhost'</code></h2>
<p>一般出现这种情况多数是安装新版本mysql，root密码是随机的，也不是空密码，所以要通过查看随机密码进入，再进行修改原来的密码。</p>
<h3>解决方案</h3>
<h4>1.查看内置用户的随机密码</h4>
<p>下载安装MySQL的过程中，系统会自动给我们创建一个用户，我们借助如下指令便可以查看该用户信息：</p>
<p><code>sudo cat /etc/mysql/debian.cnf</code></p>
<p>返回：</p>
<pre><code>❯ sudo cat /etc/mysql/debian.cnf
# Automatically generated for Debian scripts. DO NOT TOUCH!
[client]
host     = localhost
user     = debian-sys-maint
password = R4ZiuvNnNykAuP9N
socket   = /var/run/mysqld/mysqld.sock
[mysql_upgrade]
host     = localhost
user     = debian-sys-maint
password = R4ZiuvNnNykAuP9N
socket   = /var/run/mysqld/mysqld.sock
</code></pre>
<h4>2.进入MySQL</h4>
<p>然后使用<code>debian-sys-maint</code>和<code>R4ZiuvNnNykAuP9N</code>(看<code>password</code>那一行，这个是随机生成的，我的和你的不一样)<strong>进入MySQL</strong>：</p>
<p><code>mysql -u debian-sys-maint -p</code></p>
<p>在显示<code>Enter password:</code>之后输入<code>password</code>那一行后面的密码，此时密码不会显示（<s>copy下来就对了</s></p>
<h4>3.修改root账户密码</h4>
<p>先查看一下原来的用户表：</p>
<pre><code>use mysql;
select user,plugin from user;
</code></pre>
<p>输出：</p>
<pre><code>mysql&gt; use mysql;
t user,plugin from user;Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql&gt; select user,plugin from user;
+------------------+-----------------------+
| user             | plugin                |
+------------------+-----------------------+
| lkhsss           | caching_sha2_password |
| debian-sys-maint | caching_sha2_password |
| mysql.infoschema | caching_sha2_password |
| mysql.session    | caching_sha2_password |
| mysql.sys        | caching_sha2_password |
| root             | auth_socket           |
+------------------+-----------------------+
6 rows in set (0.00 sec)
</code></pre>
<p>可以看到root账户的密码格式为<code>auth_socket </code>。</p>
<p>现在来修改一下root账户的密码格式:</p>
<pre><code>update user set plugin='mysql_native_password' where user='root'; # 修改其密码格式
select user,plugin from user; # 查询其用户
</code></pre>
<p>输出：</p>
<pre><code>mysql&gt; update user set plugin='mysql_native_password' where user='root';
Query OK, 0 rows affected (0.00 sec)
Rows matched: 1  Changed: 0  Warnings: 0

mysql&gt; select user,plugin from user;
+------------------+-----------------------+
| user             | plugin                |
+------------------+-----------------------+
| lkhsss           | caching_sha2_password |
| debian-sys-maint | caching_sha2_password |
| mysql.infoschema | caching_sha2_password |
| mysql.session    | caching_sha2_password |
| mysql.sys        | caching_sha2_password |
| root             | mysql_native_password |
+------------------+-----------------------+
6 rows in set (0.00 sec)
</code></pre>
<p>修改好后要刷新权限</p>
<pre><code>flush privileges;
</code></pre>
<p>然后新增密码：</p>
<p><code>alter user 'root'@'localhost' identified by '密码';</code></p>
<p>再刷新一次</p>
<pre><code>flush privileges;
</code></pre>
<p>退出</p>
<pre><code>exit
</code></pre>
<h4>4.重启服务</h4>
<pre><code>service mysql restart
</code></pre>
<p>现在即可用<code>mysql -u root -p</code>，然后使用刚刚设置的密码登陆了</p>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Go语言基础语法</title>
    <link href="https://www.lkhssssss.cn/posts/go/go-grammar/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/go/go-grammar/</id>
    <published>2023-03-04T17:23:36.000Z</published>
    <updated>2023-03-04T17:23:36.000Z</updated>
    <summary>Go语言最简单的运行方式已经用HelloWorld体验过了，那么现在就来啃编程语言最基础的语法吧。</summary>
    <content type="html"><![CDATA[<h2>行代码</h2>
<p>Go语言的行代码由关键字，标识符，常量，字符串，符号等部分组成</p>
<p>Go语言的行代码末尾不需要加结尾符号（比如C语言中的<code>;</code>），这些由编译器自动完成。</p>
<blockquote>
<p>[!TIP]
<strong>当然</strong>，多个语句写在同一行时，也可以用<code>;</code>手动将其区分。但是不推荐写成这样：</p>
<pre><code>fmt.Println("hiahiahia");fmt.Println("不推荐此用法")
</code></pre>
<p>推荐写成这样，增加代码的可阅读性：</p>
<pre><code>fmt.Println("hiahiahia")
fmt.Println("推荐此用法")
</code></pre>
</blockquote>
<h2>标识符</h2>
<p>标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。标识符通常由字母和数字以及其它字符构成。
Go语言的标识符实际上是由 <strong>一个或是多个字母(A<s>Z和a</s>z)、数字(0~9)、下划线<code>_</code></strong> 组成的序列，但是第一个字符必须是<strong>字母或下划线</strong>而不能是数字或关键字。</p>
<h2>字符串</h2>
<p>和其他语言相同，但是Go语言字符串的特性是可以用<code>+</code>将两端字符串直接拼接在一起。
首尾相连，就像这样：</p>
<pre><code>fmt.Println("Hello" + "World")	//此行将输出HelloWorld
fmt.Println("HelloWorld")			//此行也将输出HelloWorld
</code></pre>
<p><s>怎么感觉又把Python基础学了一遍（</s></p>
<h2>保留字</h2>
<p>以下是一些常用的保留字</p>
<table>
<thead>
<tr>
<th>保留字</th>
<th>作用</th>
<th>保留字</th>
<th>作用</th>
</tr>
</thead>
<tbody>
<tr>
<td>package</td>
<td>定义包名</td>
<td>default</td>
<td></td>
</tr>
<tr>
<td>func</td>
<td>定义函数</td>
<td>interface</td>
<td></td>
</tr>
<tr>
<td>import</td>
<td>引入包</td>
<td>break</td>
<td></td>
</tr>
<tr>
<td>var</td>
<td>定义变量</td>
<td>case</td>
<td></td>
</tr>
<tr>
<td>defer</td>
<td></td>
<td>go</td>
<td></td>
</tr>
<tr>
<td>struct</td>
<td></td>
<td>map</td>
<td></td>
</tr>
<tr>
<td>else</td>
<td></td>
<td>chan</td>
<td></td>
</tr>
<tr>
<td>switch</td>
<td></td>
<td>goto</td>
<td></td>
</tr>
<tr>
<td>fallthrough</td>
<td></td>
<td>if</td>
<td></td>
</tr>
<tr>
<td>range</td>
<td></td>
<td>type</td>
<td></td>
</tr>
<tr>
<td>continue</td>
<td></td>
<td>return</td>
<td></td>
</tr>
<tr>
<td>for</td>
<td></td>
<td>select</td>
<td></td>
</tr>
<tr>
<td>const</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>WSL如何迁移位置？</title>
    <link href="https://www.lkhssssss.cn/posts/move-wsl/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/move-wsl/</id>
    <published>2023-02-26T21:22:06.000Z</published>
    <updated>2023-02-26T21:22:06.000Z</updated>
    <summary>WSL子系统默认硬盘存放位置在c盘，对于很多人来说都想安装到别的盘内。设置里的迁移应用功能使用亲测会有Bug(无法启动)，Google一番后终于找到了解决方案，特在此记录。</summary>
    <content type="html"><![CDATA[<p>WSL子系统默认硬盘存放位置在c盘，对于很多人来说都想安装到别的盘内。设置里的迁移应用功能使用亲测会有Bug(无法启动)，Google一番后终于找到了解决方案，特在此记录。</p>
<p>==此方案也可以用于备份WSL或单纯导出WSL==</p>
<p><strong>前提</strong>：已经安装WSL</p>
<hr />
<h2>关闭虚拟机</h2>
<p>终端输入 <code>wsl --shutdown</code> 以关闭虚拟机</p>
<h2>查看已安装的WSL</h2>
<p>终端输入</p>
<pre><code>wsl -l
</code></pre>
<p>若要查看其他信息，则使用</p>
<pre><code>wsl -l -v
</code></pre>
<h2>导出虚拟机</h2>
<pre><code>wsl --export &lt;需要导出的虚拟机&gt; &lt;导出路径&gt;
</code></pre>
<p>例：</p>
<pre><code>wsl --export Ubuntu G:\WSL\Ubuntu\ubuntu(2023.2.25备份).tar
</code></pre>
<h2>注销已经安装过的虚拟机</h2>
<pre><code>wsl --unregister &lt;虚拟机的名称&gt;
</code></pre>
<p>例：</p>
<pre><code>wsl --unregister Ubuntu
</code></pre>
<h2>重新导入虚拟机</h2>
<pre><code>wsl --import &lt;虚拟机的名称&gt; &lt;安装虚拟机的位置&gt; &lt;打包文件的位置&gt;
</code></pre>
<p>例：</p>
<pre><code>wsl --import Ubuntu G:\WSL\Ubuntu G:\WSL\Ubuntu\ubuntu(2023.2.25备份).tar
</code></pre>
<hr />
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Go语言结构</title>
    <link href="https://www.lkhssssss.cn/posts/go/go-strcture/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/go/go-strcture/</id>
    <published>2023-02-19T08:38:27.000Z</published>
    <updated>2023-02-19T08:38:27.000Z</updated>
    <summary></summary>
    <content type="html"><![CDATA[<h2>语言结构</h2>
<p>既然是学习语言结构，那么还是用最简单的HelloWorld演示好了</p>
<pre><code>package main /* 包声明 */

import "fmt" /* 引入包 */

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")//基本的输出语句，将自动换行
   //这是一条单行注释
   /* 这是
   一条
   多行
   注释
   */
}
</code></pre>
<h3>包声明</h3>
<p><code>package main</code>定义了包名。一个Go程序必须在源文件中非注释的第一行指明这个文件属于哪个包。</p>
<p>package main表示一个可独立执行的程序，<strong>每个 Go 应用程序都包含一个名为 <code>main</code> 的包</strong>。</p>
<p>注意：</p>
<ul>
<li>文件名与包名没有直接关系，不一定要将文件名与包名定成同一个</li>
<li>文件夹名与包名没有直接关系，并非需要一致</li>
<li>同一个文件夹下的文件只能有一个包名，否则编译报错。{% label danger @package command-line-arguments is not a main package %}</li>
</ul>
<h3>引入包</h3>
<p><code>import "fmt"</code> 告诉 Go 编译器这个程序需要使用 <code>fmt</code> 包（的函数，或其他元素），<code>fmt</code> 包实现了基本的格式化 I/O（输入/输出）</p>
<p>约等于Python中的<code>print()</code>函数</p>
<h3>函数</h3>
<p><code>func</code>是Go语言定义函数的方法。</p>
<p>约等于Python中的<code>def main():</code></p>
<p><code>func main()</code> 是程序开始执行的函数。<code>main()</code> 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数</p>
<p>如果有 <code>init()</code> 函数则会先执行该函数。</p>
<h3>变量</h3>
<p>与其他语言相通</p>
<p>但需要注意的是：当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。</p>
<h3>语句</h3>
<p><code>fmt.Println()</code> 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
使用 <code>fmt.Print("hello, world\n")</code> 可以得到相同的结果。
<code>Print</code> 和 <code>Println</code> 这两个函数也支持使用变量，如：<code>fmt.Println(arr)</code> 。如果没有特别指定，它们会以默认的打印格式将变量 <code>arr</code> 输出到控制台。</p>
<h3>注释</h3>
<p>使用以 <code>//</code> 开头的单行注释，而<code>/*...*/</code> 是多行注释，这点与C和C嘎嘎是相似的。</p>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>Go: Hello World!</title>
    <link href="https://www.lkhssssss.cn/posts/go/go-helloworld/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/go/go-helloworld/</id>
    <published>2023-02-19T08:17:10.000Z</published>
    <updated>2023-02-19T08:17:10.000Z</updated>
    <summary>学习Go语言的第一步！</summary>
    <content type="html"><![CDATA[<h2>Go语言环境搭建</h2>
<p>官方下载地址：<a href="https://golang.org/dl/">https://golang.org/dl/</a></p>
<p>镜像站：<a href="https://golang.google.cn/dl/">https://golang.google.cn/dl/</a></p>
<hr />
<h2>Hello World!</h2>
<p>学习一门语言的第一步，那必定是去copy一份经典的HelloWorld啦 :)</p>
<pre><code>package main

import "fmt"

func main() {
   /* 这是一个简单的程序 */
   fmt.Println("Hello, World!")
}
</code></pre>
<p>随便创建一个文件，修改后缀为<code>.go</code>，直接把上面的代码copy进去。</p>
<p>作为第一个程序，我理所当然地取名为<code>helloworld.go</code></p>
<p>保存后直接一顿操作在<strong>当前目录</strong>打开终端，输入：</p>
<pre><code>go run helloworld.go
</code></pre>
<p>如果成功的话，会输出：</p>
<pre><code>~$ go run helloworld.go
Hello, World!
</code></pre>
<p>如果显示<code>'go'不是内部或外部命令，也不是可运行的程序或批处理文件。</code>，那应当为Go语言添加系统环境，或这重新安装。</p>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>kali更换镜像源</title>
    <link href="https://www.lkhssssss.cn/posts/kali-mirror/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/kali-mirror/</id>
    <published>2023-02-04T20:05:16.000Z</published>
    <updated>2023-02-04T20:05:16.000Z</updated>
    <summary>你想吃牢饭？</summary>
    <content type="html"><![CDATA[<p>源文件位置：<code>/etc/apt/sources.list</code></p>
<p>直接键入<code>sudo nano /etc/apt/sources.list</code>即可开始编辑</p>
<h2>清华源</h2>
<p><a href="https://mirrors.tuna.tsinghua.edu.cn/kali/">清华大学开源软件镜像站</a></p>
<pre><code>deb http://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
deb-src https://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
</code></pre>
<h2>阿里源</h2>
<p><a href="https://developer.aliyun.com/mirror/kali">阿里巴巴开源镜像站</a></p>
<pre><code>deb http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
deb-src http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
</code></pre>
<h2>中科大源</h2>
<p><a href="http://mirrors.ustc.edu.cn/kali">USTC Open Source Software Mirror</a></p>
<pre><code>deb http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
deb-src http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
</code></pre>
<h2>网易源</h2>
<p><a href="http://mirrors.163.com/debian/">网易开源镜像站</a></p>
<pre><code>deb http://mirrors.163.com/debian wheezy main non-free contrib
deb-src http://mirrors.163.com/debian wheezy main non-free contrib
deb http://mirrors.163.com/debian wheezy-proposed-updates main non-free contrib
deb-src http://mirrors.163.com/debian wheezy-proposed-updates main non-free contrib
deb-src http://mirrors.163.com/debian-security wheezy/updates main non-free contrib
</code></pre>
<h2>东软源</h2>
<p><a href="http://mirrors.neusoft.edu.cn/kali/">大连东软信息学院开源镜像站</a></p>
<pre><code>deb http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib
deb-src http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib
</code></pre>
<h2>官方源</h2>
<p><a href="http://http.kali.org/kali/">kali Linux | Penetration Testing Distribution</a></p>
<pre><code>deb http://http.kali.org/kali kali-rolling main non-free contrib
deb-src http://http.kali.org/kali kali-rolling main non-free contrib
</code></pre>
<h2>汇总</h2>
<pre><code>#清华大学
deb http://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
deb-src https://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
#中科大
deb http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
deb-src http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
#阿里云
deb http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
deb-src http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
#163
deb http://mirrors.163.com/debian wheezy main non-free contrib
deb-src http://mirrors.163.com/debian wheezy main non-free contrib
deb http://mirrors.163.com/debian wheezy-proposed-updates main non-free contrib
deb-src http://mirrors.163.com/debian wheezy-proposed-updates main non-free contrib
deb-src http://mirrors.163.com/debian-security wheezy/updates main non-free contrib
#东软大学
deb http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib
deb-src http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib
#官方源
deb http://http.kali.org/kali kali-rolling main non-free contrib
deb-src http://http.kali.org/kali kali-rolling main non-free contrib
</code></pre>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
  <entry>
    <title>LaTex 数学公式速查表</title>
    <link href="https://www.lkhssssss.cn/posts/latex/" rel="alternate" type="text/html"/>
    <id>https://www.lkhssssss.cn/posts/latex/</id>
    <published>2023-01-02T11:53:06.000Z</published>
    <updated>2023-01-02T11:53:06.000Z</updated>
    <summary>包含了常用LaTex公式，逐步添加中~</summary>
    <content type="html"><![CDATA[<h2>分数</h2>
<p><code>$\frac{分子}{分母}$</code></p>
<p>$\frac{分子}{分母}$</p>
<h2>派</h2>
<p><code>$\pi$</code></p>
<p>$\pi$</p>
<h2>希腊字母</h2>
<p><code>$\alpha$</code></p>
<p>$\alpha$</p>
<h2>角度符号</h2>
<p><code>$^\circ$</code></p>
<p>$^\circ$</p>
]]></content>
    <author><name>LKHSSS</name></author>
    <category term="编程"/>
  </entry>
</feed>
