Go - 数组、切片


## 总览

程序员经常会用到的集合，列表、字典、集合。比如：

- 股票池
- 股票价格

有多种选择来处理这一系列数据：

- 列表。表示一组有序的数据
- 字典。表示一组键值对的数据
- 集合。表示一组无序的数据

## 列表

当数据的顺序很重要时，使用列表。记住列表可以容纳任何类型的对象。例如，元组列表。

```python
portfolio = [
    ('GOOG', 100, 490.1),
    ('IBM', 50, 91.3),
    ('CAT', 150, 83.44)
]

portfolio[0]            # ('GOOG', 100, 490.1)
portfolio[2]            # ('CAT', 150, 83.44)

# 列表构造
records=[] #初始化一个空列表

records.append(('foo', 1, 2)) #添加元素
records.append(('bar', 'hello')) #添加元素

#从文件读取数据并写入列表
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        records.append((row[0], row[1], row[2]))
```

## 字典

如果你想要快速随机查找(按键名) ，字典是很有用的。例如，股票价格字典:

```python
prices = {
   'GOOG': 513.25,
   'CAT': 87.22,
   'IBM': 93.37,
   'MSFT': 44.12
}

prices['IBM']           # 93.37
prices['MSFT']          # 44.12

# 字典构造
prices = {} #初始化一个空字典

prices['GOOG'] = 513.25 #添加元素
prices['CAT'] = 87.22 #添加元素

#从文件读取数据并写入字典
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        prices[row[0]] = row[1]

# 字典查找
if 'GOOG' in prices:
    print('GOOG is in prices')

name = prices.get('GOOG', 'N/A') #N/A表示默认值

prices.get('GOOG', 0) # 513.25
prices.get('SCOX', 0) # 0

# 复合键 - 任何类型的数据都可以作为字典的键。例如，元组:

holidays = {
    (1, 1): 'New Year\'s Day',
    (7, 4): 'Independence Day',
    (12, 25): 'Christmas'
}
holidays[(1, 1)] # 'New Year\'s Day'
```

## 集合

集合是一种特殊的字典，表示一组无序的数据，数据不重复。

```python
tech_stocks = {'GOOG', 'IBM', 'CAT'}
tech_stocks = set(['GOOG', 'IBM', 'CAT'])

names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO']

unique = set(names)
# unique = set(['IBM', 'AAPL','GOOG','YHOO'])

unique.add('CAT')        # Add an item
unique.remove('YHOO')    # Remove an item

s1 = { 'a', 'b', 'c'}
s2 = { 'c', 'd' }
s1 | s2                 # Set union { 'a', 'b', 'c', 'd' }
s1 & s2                 # Set intersection { 'c' }
s1 - s2                 # Set difference { 'a', 'b' }

```


Collections of python - 集合


内存安全是编程语言中的一个重要概念，它指的是在程序执行过程中，确保所有内存访问都是合法的、有效的，不会导致内存泄漏、访问未初始化的内存或非法访问其他应用程序的内存等问题。Swift 是一种内存安全的语言，它通过一系列的机制来确保内存访问的安全性。

Swift 中的内存安全机制主要包括以下几个方面：

- ARC（Automatic Reference Counting，自动引用计数）：ARC 是一种自动内存管理机制，它通过对对象引用计数的跟踪来管理内存。当一个对象没有任何引用时，ARC 会自动释放这个对象所占用的内存。
- 可选类型：Swift 中的可选类型可以表示一个值存在或者不存在的状态，它可以避免空指针异常等问题。在 Swift 中，如果一个可选类型没有明确赋值，那么它的值默认为 nil。
- 访问控制：Swift 提供了访问控制机制，可以限制对某些代码的访问权限，从而防止未经授权的访问。
- 内存访问检查：Swift 对数组、字典、字符串等常用类型的访问进行了检查，避免了越界访问等问题。
- copy-on-write 语义：Swift 中的某些类型，比如数组和字典，采用了 copy-on-write 语义。当这些类型的值被复制时，实际上并不会立即进行复制，而是共享同一块内存空间。只有在其中一个值被修改时，才会进行实际的复制操作，从而避免了不必要的内存开销。

通过以上这些机制，Swift 可以保证程序在运行过程中不会出现内存泄漏、空指针异常等问题，从而提高了程序的可靠性和稳定性。


内存安全是编程语言中的一个重要概念，它指的是在程序执行过程中，确保所有内存访问都是合法的、有效的，不会导致内存泄漏、访问未初始化的内存或非法访问其他应用程序的内存等问题。Swift 是一种内存安全的语言，它通过一系列的机制来确保内存访问的安全性。

Swift - 内存安全


Automatic Reference Counting（ARC）是一种内存管理机制，它是由苹果公司在其 Objective-C 和 Swift 语言中使用的。ARC 的作用是在程序运行时自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。

在 Objective-C 中，ARC 是默认开启的，它通过计算对象的引用计数来自动管理对象的内存。每当一个对象被创建时，它的引用计数会被初始化为 1，每当一个对象被引用时，它的引用计数会增加 1，每当一个对象不再被引用时，它的引用计数会减少 1。当一个对象的引用计数为 0 时，它就会被自动释放掉。

在 Swift 中，ARC 同样是默认开启的，它采用了和 Objective-C 相同的引用计数机制。不同的是，在 Swift 中，我们可以使用强引用、弱引用和无主引用来管理对象的内存。强引用是最常见的引用类型，它会使对象的引用计数增加 1，并且只有在没有任何强引用指向对象时，对象的引用计数才会减少 1；弱引用和无主引用则可以用来避免循环引用的问题。

在使用 ARC 时，我们只需要遵循一些基本规则即可避免内存泄漏和野指针等问题。例如，我们可以使用 weak 或 unowned 来避免循环引用的问题；我们不应该手动管理内存，例如使用 retain、release 和 autorelease 等方法；我们需要避免在闭包中持有 self 等对象，以避免循环引用的问题等。

除了基本规则外，ARC 还提供了一些高级特性，例如自动闭包和无主引用等。下面我们来看一些常见的 ARC 特性。

## 自动闭包

自动闭包是一种方便的语法结构，它可以让我们把一个表达式封装成一个闭包，并在需要时自动调用它。在 Swift 中，我们可以使用 @autoclosure 关键字来声明一个自动闭包。例如：

```swift
func printIfTrue(_ predicate: @autoclosure () -> Bool) {
  if predicate() {
    print("True")
  } else {
    print("False")
  }
}

printIfTrue(2 + 2 == 4)
```

在上面的代码中，我们定义了一个 printIfTrue 函数，它接受一个返回 Bool 类型的自动闭包作为参数，并在需要时自动调用它。在调用该函数时，我们可以传递一个表达式，例如 2 + 2 == 4，这个表达式会被自动封装成一个闭包，并在 printIfTrue 函数中被调用。

## 无主引用

无主引用是一种特殊的弱引用，它用来避免弱引用在使用时被意外释放的问题。在 Swift 中，我们可以使用 unowned 关键字来声明一个无主引用。例如：

```swift
class Person {
  var name: String
  var apartment: Apartment?

    init(name: String) {
        self.name = name
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
  let number: Int
  weak var tenant: Person?

    init(number: Int) {
        self.number = number
    }

    deinit {
        print("Apartment #\(number) is being deinitialized")
    }
}

var john: Person?
var number73: Apartment?

john = Person(name: "John")
number73 = Apartment(number: 73)

john!.apartment = number73
number73!.tenant = john

john = nil
number73 = nil
```

在上面的代码中，我们定义了一个 Person 类和一个 Apartment 类，它们之间通过弱引用和无主引用进行关联。具体来说，Person 类中的 apartment 属性是一个可选的 Apartment 类型，并且它是通过弱引用来实现的；而 Apartment 类中的 tenant 属性是一个可选的 Person 类型，并且它是通过无主引用来实现的。这样，在我们释放 john 和 number73 变量所占用的内存时，它们之间的引用关系就可以正确地被解除。

总的来说，ARC 是一种非常方便和安全的内存管理机制，它可以自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。在使用 ARC 时，我们只需要遵循一些基本规则和高级特性即可，从而让我们更加专注于应用程序的业务逻辑。


ARC 的作用是在程序运行时自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。

Swift - ARC(内存管理机制)


## Go 介绍

Go 也称为 Golang，是 Google 开发的一种开源，编译和静态类型的编程语言。Go 创作背后的关键人物是 Rob Pike， Ken Thompson 和 Robert Griesemer。Go 于 2009 年 11 月公开发布。

Go 是一种通用的编程语言，具有简单的语法，并具有强大的标准库作为后盾。Go 大放异彩的关键领域之一是创建高可用性和可伸缩性的 Web 应用程序。Go 还可以用于创建命令行应用程序，桌面应用程序甚至移动应用程序。

## Go 优点

当大量其他语言（例如 python，ruby，nodejs ...）执行相同的工作时，为什么选择 Go 作为服务器端编程语言。

这是我选择 Go 时发现的一些优点。

### 简单语法

语法简单明了，并且该语言不会因不必要的功能而肿。这使得编写可读性和可维护性的代码变得容易。

### 易于编写并发程序

并发是语言的固有部分。结果，编写多线程程序简直是小菜一碟。这是通过 Goroutines 和渠道实现的，我们将在接下来的教程中对其进行讨论。

### 编译语言

Go 是一种编译语言。源代码被编译为本地二进制文件。解释语言（例如，nodejs 中使用的 JavaScript）缺少此功能。

### 快速编译

Go 编译器非常神奇，并且从一开始就被设计为快速的。

### 静态链接

Go 编译器支持静态链接。整个 Go 项目可以静态链接到一个大的二进制文件中，并且可以轻松部署在云服务器中，而不必担心依赖关系。

### Go 工具

工具在 Go 中值得特别提及。Go 附带了功能强大的工具，可帮助开发人员编写更好的代码。很少有常用的工具是

- gofmt- gofmt 用于自动格式化 go 源代码。它使用制表符进行缩进，并使用空格进行对齐。
- vet- vet 分析 go 源代码并报告可能的可疑代码。vet 报告的所有内容都不是真正的问题，但是具有捕获编译器未报告的错误的能力，例如使用 Printf 时格式不正确的说明符。
- golint- golint 用于识别代码中的样式问题。

### 垃圾收集

Go 使用垃圾回收，因此内存管理几乎会自动执行，开发人员无需担心内存管理问题。这也有助于轻松地编写并发程序。

### 简单语言规范

语言规范非常简单。在整个规范在页面千篇一律，你甚至可以用它来写你自己的编译器:)

### 开源的

最后但并非最不重要的一点是，Go 是一个开源项目。您可以参与 Go 项目并为该项目做出贡献。

## 使用 Go 构建的热门产品

以下是一些使用 Go 构建的流行产品。

- Google 使用 Go 开发了 Kubernetes。
- Docker 是世界著名的容器化平台，是使用 Go 开发的。
- Dropbox 已将其性能关键组件从 Python 迁移到 Go。
- Infoblox 的下一代网络产品是使用 Go 开发的。

## 安装

Go 可以安装在 Mac，Windows 和 Linux 这三个平台上。您可以从https://golang.org/dl/下载对应平台的二进制文件

### Mac

从https://golang.org/dl/下载Mac OS 安装程序。双击开始安装。按照提示进行操作，这会将 Golang 安装在/usr/local/go 中，并且还将文件夹/usr/local/go/bin 添加到 PATH 环境变量中。

```bash
# if you don't have git install it like so:
brew install git

# then install go
brew install go

# add GOBIN path to your PATH in ~/.bash_profile
export PATH=${HOME}/go/bin:$PATH
```

### Windows

从https://golang.org/dl/下载MSI安装程序。双击开始安装，然后按照提示进行操作。这会将Go安装在位置c:\Go，还将目录c:\Go\ bin 添加到您的路径环境变量中。

### Linux

从https://golang.org/dl/下载tar文件并将其解压缩到/usr/local。

将/usr/local/go/bin 添加到 PATH 环境变量中。

## 验证安装

要验证 Go 安装是否成功，请 go version 在终端中键入命令，它将输出已安装的 Go 版本。这是我终端的输出。

```bash
$ go version
go version go1.13.6 darwin/amd64
```


Go - 简介


## 前置

[【上一篇】](/blog/javascript/nextjs/tips/add-theme-mode-switch-to-blog)完成了使用 Next.js 构建 blog 并添加了主题切换功能。

好的 SEO 将有助于提高网站权重，带来更多流量。作为前端工程师的我们，就有着得天独厚的优势，我们不需要做到优化工程师的级别，我们只需要做好几个方面，就能完成一个网站 80%左右的 SEO 优化工作了～因为我研究下来发现 SEO 针对点大部分都是前端基础～

## 创建组件

创建`components/SEO/index.tsx`

```tsx
import {NextSeo} from 'next-seo'

export default function SEO(props) {
  const {url, cover, description, title} = props
  return (
    <NextSeo
      titleTemplate="%s - Manon.icu"
      openGraph={{
        type: 'website',
        url,
        description:
          description ??
          'The personal website for Manon, Frontend Web Developer.',
        site_name: title ?? 'Manon | manon.icu',
        images: [
          {
            url: cover ?? 'https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/9oh25b.jpg',
            width: 900,
            height: 900
          }
        ]
      }}
      canonical={url}
      twitter={{
        handle: '@Manonicu',
        cardType: 'summary_large_image'
      }}
    />
  )
}
```

修改`pages/_app.tsx`，引入`components/SEO/index.tsx`，在`Head`下添加 SEO 组件，组件加上 props`url`

在 blog 内页同样引入，分别传入`title`、`description`、`cover`

```tsx
// pages/[...slug].tsx
// <SEO
//   title={title}
//   description={description}
//   cover={cover}
//   openGraph={{title, description}}
// />
```

[Source Code](https://github.com/Manonicu/blog-demo/tree/feat-seo)


从性能、打包大小、SEO来看，Next.js可能是最适合写blog的React框架。

Next.js - Add Next-seo


在 ECMAScript 中，变量可以存在两种类型的值，即原始值和引用值。

1. 原始值占用的内存空间是固定的，而引用值占用的内存空间是动态的。
2. 原始值的值存储在栈中，而引用值的值存储在堆中。
3. 原始值的保存与复制是直接的，而引用值的保存与复制是通过值的拷贝来实现的。
4. 原始值使用`typeof`运算符来检测其类型，而引用值使用`instanceof`运算符来检测其类型。
5. 原始值的值可以通过`==`运算符来比较，而引用值的值可以通过`===`运算符来比较。
6. 使用`new()`构造出的对象是引用值，而不是原始值。

> 除了`null`和`undefined`之外，所有的基本类型都是原始值，而所有的引用类型都是引用值。

## 基本类型

- number
- boolean
- bigint
- string
- symbol
- null
- undefined

## 引用类型

- object
- array
- function

```js
const number = 10

const bool = false

const str = 'Hello!'

const missingObject = null

const nothing = undefined
```

基本类型的值是存储在栈中的，所以在 JavaScript 中，基本类型的值可替换但不可被改变。

```js
var bar = 'baz'
console.log(bar) // baz
bar.toUpperCase()
console.log(bar) // baz

// 使用数组方法可以改变一个数组
var foo = []
console.log(foo) // []
foo.push('plugh')
console.log(foo) // ["plugh"]

// 赋值行为可以给基本类型一个新值，而不是改变它
bar = bar.toUpperCase() // BAZ
```

```js
// 基本类型
let foo = 5

// 定义一个貌似可以改变基本类型值的函数
function addTwo(num) {
  num += 2
}
// 和前面的函数一样
function addTwo_v2(foo) {
  foo += 2
}

// 调用第一个函数，并传入基本类型值作为参数
addTwo(foo)
// Getting the current Primitive value
console.log(foo) // 5

// 尝试调用第二个函数...
addTwo_v2(foo)
console.log(foo) // 5
```

**在执行函数体内语句之前，JavaScript 会将传递进来的参数（基本类型的值）复制一份，创建一个本地副本。这个副本只存在于该函数的作用域中，我们能够通过指定在函数中的标识符访问到它（addTwo 中的 num，addTwo_v2 中的 foo）。**
