Go - 变量、类型、常量


`path` 模块提供了许多非常实用的函数来访问文件系统并与文件系统进行交互

```js
const path = require('path);
```

## 方法

- `baseName(p, ext)`: 返回路径中的文件名，不包括扩展名
- `dirName(p)`: 返回路径中的目录名
- `extname(p)`: 返回路径中的扩展名
- `isAbsolute(p)`: 判断路径是否是绝对路径
- `join(...paths)`: 将多个路径连接成一个路径
- `normalize(p)`: 将路径规范化
- `parse(pathString)`: 解析路径字符串
- `relative(from, to)`: 返回路径 `from` 和路径 `to` 相对于当前工作目录的相对路径
- `resolve(...pathSegments)`: 解析路径字符串

## 属性

- `sep`: 路径分隔符
- `posix`: posix 路径
- `win32`: win32 路径
- `delimiter`: 路径分隔符

```js
const path = require('path')

// Normalization
console.log(
  'normalization : ' + path.normalize('/test/test1//2slashes/1slash/tab/..')
) //normalization : /test/test1/2slashes/1slash

// Join
console.log(
  'joint path : ' + path.join('/test', 'test1', '2slashes/1slash', 'tab', '..')
) //joint path : /test/test1/2slashes/1slash

// Resolve
console.log('resolve : ' + path.resolve('main.js')) // resolve : /web/com/1427176256_27423/main.js

// extName
console.log('ext name : ' + path.extname('main.js')) //ext name : .js
```


path 模块提供了许多非常实用的函数来访问文件系统并与文件系统进行交互

Node.js - Path


## 原始值和引用值

> 了解如何将对象，数组和函数复制并传递给函数。要知道引用时复制了什么。理解原始值是通过复制值来进行复制和传递的。

## 作用域

> 了解全局作用域，函数作用域和块作级用域之间的区别。了解哪些变量在哪些地方可用。知道 JavaScript 引擎如何执行变量查找。

## 提升

> 理解变量和函数声明会被提升到可用作用域的顶部。 理解函数表达式不会被提升。

## 闭包

> 知道一个函数保留，并且可以访问创建它的作用域。知道这些可以让我们做什么，例如数据隐藏、内存化以及动态函数生成。

## this

> 知道 this 绑定的规则。知道它的工作机制，知道如何弄清楚在一个函数中它等同于什么，或者说指向什么？并知道为什么它是有用的。

## new

> 知道它如何与面向对象编程相关。知道用 new 调用的函数会发生什么。理解如何使用 new 来继承函数 prototype(原型) 属性生成的对象。

## apply、call、bind

> 知道这些函数的工作机制。 知道如何使用它们。了解它们对 this 做了什么。

## 原型和继承

> 了解 JavaScript 中的继承是通过 [[Prototype]] 链实现的。了解如何通过函数和对象来设置继承，以及 new 是如何帮助我们实现的。知道 **proto** 和 prototype 属性是什么，以及他们的作用。

## 异步和同步

> 理解事件循环，理解浏览器是如何处理用户输入、Web 请求和一般事件的。知道如何识别并正确实现异步代码。理解 JavaScript 中异步和单线程分别是怎样的。

## 高阶函数

> 理解这些函数是 JavaScript 中的一等公民，以及这意味着什么。 知道从另一个函数返回一个函数是完全合法的。 了解闭包和更高阶函数允许我们使用的技巧


JS概念扩展


协议（Protocol）是 Swift 中一种重要的类型，它描述了一种方法或者属性的集合。协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

协议定义了一些方法和属性，但不提供任何实现。实现协议的类型，必须遵循协议的要求并提供这些方法和属性的实际实现。

协议的语法如下：

```swift

protocol SomeProtocol {
// 协议定义
}
```

接下来，我们将了解协议的常见用法和特性。

## 协议的属性要求

协议可以要求实现者提供特定名字和类型的实例属性或类型属性。协议不指定属性是存储属性还是计算属性，只指定属性的名称和类型。此外，协议还要求属性是可读写的或只读的。

实现协议的类型，必须遵循协议的要求并提供这些属性的实际实现。如果协议要求实现的属性是可读写的，那么实现者必须提供一个可读写的属性实现；如果协议要求实现的属性是只读的，那么实现者可以提供一个可读的属性实现或一个只读的计算属性实现。

下面是一个协议属性要求的例子：

```swift

protocol Person {
var name: String { get set }
var age: Int { get }
}
```

这个协议定义了两个属性要求，name 和 age。name 是一个可读写的字符串类型的实例属性，age 是一个只读的整数类型的实例属性。

接下来，我们定义一个结构体 Student 来实现 Person 协议：

```swift

struct Student: Person {
var name: String
var age: Int
}
```

Student 结构体实现了 Person 协议，并提供了 name 和 age 属性的实现。由于 Person 协议要求 name 是可读写的，因此 Student 结构体提供了一个可读写的 name 属性实现。而 Person 协议要求 age 是只读的，因此 Student 结构体提供了一个只读的 age 属性实现。

## 协议的方法要求

协议可以要求实现者提供特定名字和类型的实例方法和类型方法。实现协议的类型，必须遵循协议的要求并提供这些方法的实际实现。

和属性要求一样，协议中的方法要求只定义方法名、参数以及返回类型，但不提供具体的实现。实现者必须自行实现这些方法。

下面是一个协议方法要求的例子：

当一个类型符合一个协议时，我们称这个类型为遵循该协议。协议定义了一组要求，遵循该协议的类型必须满足这些要求。

在 Swift 中，协议可以用来实现多态。这意味着，我们可以使用一个遵循该协议的实例来代替任何符合该协议的类型的实例，从而使代码更加通用。

下面是一些常见的协议和它们的使用方法：

## CustomStringConvertible

该协议可以让我们自定义类型的字符串描述。当我们打印一个遵循 CustomStringConvertible 协议的类型时，它将返回一个字符串描述。这在调试和日志记录时非常有用。

下面是一个实现 CustomStringConvertible 协议的例子：

```swift

struct Person: CustomStringConvertible {
let name: String
let age: Int

    var description: String {
        return "\(name), \(age) years old"
    }
}

let person = Person(name: "Alice", age: 28)
print(person) // Output: Alice, 28 years old
```

## Equatable

该协议可以让我们比较两个实例是否相等。当我们需要比较两个对象时，遵循 Equatable 协议的类型会自动获得 == 运算符的实现。

下面是一个实现 Equatable 协议的例子：

```swift

struct Point: Equatable {
let x: Int
let y: Int
}

let point1 = Point(x: 1, y: 2)
let point2 = Point(x: 1, y: 2)

if point1 == point2 {
print("The two points are equal.")
} else {
print("The two points are not equal.")
}
```

## Hashable

该协议可以让我们将一个类型实例转换为一个唯一的哈希值。遵循 Hashable 协议的类型可以用作字典的键或集合的元素。

下面是一个实现 Hashable 协议的例子：

```swift

struct User: Hashable {
let id: Int
let name: String
}

let user1 = User(id: 1, name: "Alice")
let user2 = User(id: 2, name: "Bob")

var userDict = [user1: "Alice", user2: "Bob"]
print(userDict[user1]) // Output: Optional("Alice")
```

## Codable

该协议可以让我们将一个类型编码为 JSON 或解码 JSON。遵循 Codable 协议的类型可以通过编码和解码操作在 Swift 和其他语言之间进行转换。

下面是一个实现 Codable 协议的例子：

```swift

struct Person: Codable {
let name: String
let age: Int
}

let person = Person(name: "Alice", age: 28)

let encoder = JSONEncoder()
let data = try encoder.encode(person)

let decoder = JSONDecoder()
let decodedPerson = try decoder.decode(Person.self, from: data)

print(decodedPerson) // Output: Person(name: "Alice", age: 28)
```


协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

Swift - 协议


## 屏幕

### 屏幕大小

> 屏幕尺寸是屏幕的宽度和高度: 显示器、手机等设备屏幕。

![Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/OrJAie.jpg)

`window.screen` 属性可以获取屏幕尺寸，其中包含屏幕的宽度和高度，以像素为单位。

```js
const screenWidth = window.screen.width
const screenHeight = window.screen.height
```

### 可用屏幕大小

> 可用屏幕尺寸是屏幕的宽度和高度，不包含任何系统窗口，以像素为单位。

![Available Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/nYbW0L.jpg)

```js
const availableScreenWidth = window.screen.availWidth
const availableScreenHeight = window.screen.availHeight
```

## 视窗

### 视窗外部宽高

> 窗口的外部大小由整个浏览器窗口的宽度和高度组成，包括地址栏、标签栏和其他浏览器面板。

![Window Outer Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/8muma1.jpg)

使用`outerWidth`和`outerHeight`可以获取窗口的外部宽高，以像素为单位。

```js
const windowOuterWidth = window.outerWidth
const windowOuterHeight = window.outerHeight
```

### 视窗内部大小

> 视窗的内部大小由整个浏览器窗口的宽度和高度组成，不包括地址栏、标签栏和其他浏览器面板。

![Window Inner Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YHT2o8.jpg)

使用`innerWidth`和`innerHeight`可以获取窗口的内部宽高，以像素为单位。

```js
const windowInnerWidth = window.innerWidth
const windowInnerHeight = window.innerHeight

/*不包含滚动条*/
const windowInnerWidth = document.documentElement.clientWidth
const windowInnerHeight = document.documentElement.clientHeight
```

## 页面大小

> 页面大小是页面内容的宽度和高度(不包含边框、边距和滚动条)。

![Page Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/Bk8qhy.jpg)

```js
const pageWidth = document.documentElement.scrollWidth
const pageHeight = document.documentElement.scrollHeight
// 如果 pageHeight 大于 window.innerHeight，则页面会出现横向滚动条
```


如何获取 Screen、Window、Page 等组件的宽高？


在 CSS 中，有多种不同的 sizing units（尺寸单位）可以用来定义元素的尺寸和位置，下面是一些常见的 sizing units：

- px（像素）：像素是 CSS 中最常用的尺寸单位之一，它指的是屏幕上的一个物理像素。因为像素是一个固定的尺寸，所以使用像素定义元素的大小可以确保它们在不同的设备上显示一致。
- %（百分比）：百分比单位是相对于父元素的大小来定义元素的尺寸。例如，如果一个元素的宽度设置为 50%，那么它的宽度将会是其父元素宽度的一半。
- em（字号）：em 是相对于元素的字体大小来定义尺寸的单位。例如，如果一个元素的字体大小为 16px，那么 1em 将等于 16px。
- rem（根字号）：rem 也是相对于字体大小来定义尺寸的单位，但是它是相对于根元素的字体大小来计算的。例如，如果根元素的字体大小为 16px，那么 1rem 将等于 16px。
- vw/vh（视窗宽度/高度）：vw 和 vh 是相对于视口宽度和高度来定义尺寸的单位。例如，如果一个元素的宽度设置为 50vw，那么它的宽度将会是视口宽度的一半。
- vmin/vmax（视口宽度/高度的较小或较大值）：vmin 和 vmax 也是相对于视口宽度和高度来定义尺寸的单位。vmin 指的是视口宽度和高度中较小的值，而 vmax 则指的是较大的值。

除了以上列举的 sizing units，CSS 还有一些其他的尺寸单位，如 pt（磅）、pc（派卡）等，但它们在网页设计中使用较少。需要注意的是，不同的 sizing units 适用于不同的场景，根据具体需求选择合适的尺寸单位来定义元素的尺寸和位置是非常重要的。

## 案例

以下是使用不同 sizing units 的 CSS 示例：

1. px（像素）

```css
div {
  width: 200px;
  height: 150px;
  font-size: 16px;
}
```

2. %（百分比）

```css
.parent {
  width: 500px;
  height: 300px;
}

.child {
  width: 50%;
  height: 50%;
}
```

3. em（字号）

```css
.parent {
  font-size: 16px;
}

.child {
  width: 10em;
  height: 5em;
}
```

4. rem（根字号）

```css
html {
  font-size: 16px;
}

.child {
  width: 20rem;
  height: 10rem;
}
```

5. vw/vh（视窗宽度/高度）

```css
.child {
  width: 50vw;
  height: 25vh;
}
```

6. vmin/vmax（视口宽度/高度的较小或较大值）

```css
.child {
  width: 50vmin;
  height: 50vmax;
}
```


css - 尺寸单位


![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20200427135628.png)

这是一份为 Web 开发准备的 Mac 配置指南，包括推荐工具，快捷方式，技巧等

- macOS Settings
  - System preferences
  - Finder
  - Screenshot
- macOS Shortcuts
- Command-line Tools
  - Homebrew
  - iTerm2
  - Git
  - Zsh
  - Oh My Zsh
  - Node.js
  - Docker
  - tldr
  - htop
  - fzf
  - ripgrep
  - path-extractor
  - lnav
- MacOS Applications
  - Visual Studio Code
  - Rectangle
  - GIMP
  - LICEcap
  - Alfred
  - Numi
- Tips and Tricks
