在 Swift 中，继承(Inheritance)是一种定义新类的方法，使其从现有类继承属性和方法。新类称为子类(Subclass)，被继承的类称为父类(Superclass)。

Swift - 继承


`Node.js`提供了一个`fs`模块，用于操作文件系统。通过`fs`模块，可以读取文件，创建文件，删除文件，移动文件，复制文件等。

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

## sync 和 async

`fs`模块中的每个方法都有`sync`和`async`两种形式。异步方法会返回一个`Promise`对象，而同步方法会返回一个`callback`。

```bash
echo "hello world" > demo.txt
```

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

// 异步读取文件
fs.readFile('demo.txt', function (err, data) {
  if (err) {
    return console.error(err)
  }
  console.log('Asynchronous read: ' + data.toString())
})

// 同步读取文件
var data = fs.readFileSync('demo.txt')
console.log('Synchronous read: ' + data.toString())

console.log('Program Ended')
```

## 打开文件

语法：`fs.open(path, flags, [mode], callback)`

- `path`: 文件路径
- `flags`: 打开文件的方式，可以是`r`，`r+`，`w`，`w+`，`a`，`a+`，`x`，`x+`，`t`，`t+`，`c`，`c+`
- `mode`: 打开文件的模式，默认是`0o666`
- `callback`: 回调函数，参数为 err,fd

```js
const fs = require('fs')
fs.open('demo.txt', 'r', function (err, fd) {
  if (err) {
    return console.error(err)
  }
  console.log('文件打开成功，文件描述符：' + fd)
})
```

## 获取文件信息

语法：`fs.stat(path, callback)`

- `path`: 文件路径
- `callback`: 回调函数，参数为 err,stats

方法：

- `stats.isFile()`: 判断是否是文件
- `stats.isDirectory()`: 判断是否是目录
- `stats.isBlockDevice()`: 判断是否是块设备
- `stats.isCharacterDevice()`: 判断是否是字符设备
- `stats.isSymbolicLink()`: 判断是否是符号链接
- `stats.isFIFO()`: 判断是否是 FIFO，如果是 FIFO，则返回 true，否则返回 false
- `stats.isSocket()`: 判断是否是 Socket

```js
const fs = require('fs')
fs.stat('demo.txt', function (err, stats) {
  if (err) {
    return console.error(err)
  }
  console.log(stats)
  console.log('文件类型：' + stats.isFile())
  console.log('文件大小：' + stats.size)
  console.log('文件创建时间：' + stats.birthtime)
})
```

## 写入文件

语法：`fs.writeFile(file, data, [options], callback)`

- `file`: 文件路径
- `data`: 写入的数据
- `options`: 可选参数，可以是`encoding`，`mode`，`flag`
- `callback`: 回调函数，参数为 err

```js
const fs = require('fs')
fs.writeFile('demo.txt', '我是写入的文件内容', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('数据写入成功！')
  console.log('--------我是分割线-------------')
  console.log('读取写入的数据！')
  fs.readFile('demo.txt', function (err, data) {
    if (err) {
      return console.error(err)
    }
    console.log('异步读取文件数据: ' + data.toString())
  })
})
```

## 读取文件

语法：`fs.read(fd, buffer, offset, length, position, callback)`

- `fd`：返回的文件描述符
- `buffer`：数据被写入的缓冲区
- `offset`：缓冲区写入的偏移位置
- `length`：读取的字节数
- `position`：从哪里开始读取
- `callback`：`err`、`bytesRead`、`buffer`

```js
var fs = require('fs')
var buf = new Buffer(1024)

console.log('Going to open an existing file')
fs.open('input.txt', 'r+', function (err, fd) {
  if (err) {
    return console.error(err)
  }
  console.log('File opened successfully!')
  console.log('Going to read the file')

  fs.read(fd, buf, 0, buf.length, 0, function (err, bytes) {
    if (err) {
      console.log(err)
    }
    console.log(bytes + ' bytes read')

    // Print only read bytes to avoid junk.
    if (bytes > 0) {
      console.log(buf.slice(0, bytes).toString())
    }
  })
})
```

## 关闭文件

语法：`fs.close(fd, callback)`

- `fd`：返回的文件描述符
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.open('demo.txt', 'r', function (err, fd) {
  if (err) {
    return console.error(err)
  }
  console.log('文件打开成功，文件描述符：' + fd)
  fs.close(fd, function (err) {
    if (err) {
      return console.error(err)
    }
    console.log('文件关闭成功！')
  })
})
```

## 删除文件

语法：`fs.unlink(path, callback)`

- `path`：文件路径
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.unlink('demo.txt', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('文件删除成功！')
})
```

## 创建目录

语法：`fs.mkdir(path, [mode], callback)`

- `path`：目录路径
- `mode`：目录权限
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.mkdir('/tmp/test', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('目录创建成功！')
})
```

## 读取目录

语法：`fs.readdir(path, callback)`

- `path`：目录路径
- `callback`：回调函数，参数为 err、files

```js
const fs = require('fs')
fs.readdir('/tmp', function (err, files) {
  if (err) {
    return console.error(err)
  }
  files.forEach(function (file) {
    console.log(file)
  })
})
```

## 阅读目录

语法：`fs.readdirSync(path)`

- `path`：目录路径

```js
const fs = require('fs')
fs.readdirSync('/tmp')
```

## 删除目录

语法：`fs.rmdir(path, callback)`

- `path`：目录路径
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.rmdir('/tmp/test', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('目录删除成功！')
})
```

[入门教程](http://nodejs.cn/learn/the-nodejs-fs-module)
[Node.js 文档](http://nodejs.cn/api/buffer.html)


File System是一个文件系统模块，用于操作文件系统。

Node.js - File System


## 屏幕

### 屏幕大小

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

![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 等组件的宽高？


Linux ping 命令用于检测主机。

执行 ping 指令会使用 ICMP 传输协议，发出要求回应的信息，若远端主机的网络功能没有问题，就会回应该信息，因而得知该主机运作正常。

如下是 ping baidu.com：

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

**ping**发出请求到对应的主机，主机返回结果。

默认情况**ping**会每秒发出请求，直到使用**ctrl+c**中断，也可以使用-c times 指定接收包的次数，如：

```bash
ping -c 2 baidu.com
```

当结束**ping**命令时，屏幕上会打印出统计结果，其中包括丢包率以及速率

```bash
ping -i 3 -s 1024 -t 255 baidu.com

# -i 3 发送周期为 3秒 -s 设置发送包的大小 -t 设置TTL值为 255
```

## 参数

- `-d` 使用 Socket 的 SO_DEBUG 功能。
- `-c` 完成次数 设置完成要求回应的次数。
- `-f` 极限检测。
- `-i` 间隔秒数 指定收发信息的间隔时间。
- `-I` 网络界面 使用指定的网络接口送出数据包。
- `-l` 前置载入 设置在送出要求信息之前，先行发出的数据包。
- `-n` 只输出数值。
- `-p` 范本样式 设置填满数据包的范本样式。
- `-q` 不显示指令执行过程，开头和结尾的相关信息除外。
- `-r` 忽略普通的 Routing Table，直接将数据包送到远端主机上。
- `-R` 记录路由过程。
- `-s` 数据包大小 设置数据包的大小。
- `-t` 存活数值 设置存活数值 TTL 的大小。
- `-v` 详细显示指令的执行过程。


Linux命令ping


在 Web 开发中，focus 是一个非常重要的概念，它指的是当前文档中获取焦点的元素。当一个元素被激活时，它就成为当前文档中获取焦点的元素，此时可以通过键盘或鼠标输入数据等方式与该元素进行交互。

在 HTML 中，可以通过 tabindex 属性为元素指定一个可以聚焦的顺序，该属性的值为整数，表示元素的聚焦顺序。如果 tabindex 的值为 -1，则该元素可以通过 JavaScript 代码来聚焦，但是在键盘聚焦顺序中不参与计算。如果 tabindex 的值为 0，则该元素可以通过浏览器默认的聚焦顺序进行聚焦。

在 CSS 中，可以使用:focus 伪类选择器来为当前获取焦点的元素设置样式，例如：

```css
button:focus {
  outline: 2px solid blue;
}
```

上面的代码表示，在按钮元素被聚焦时，为其添加一个 2px 宽度、蓝色边框的外观效果。

除了样式之外，JavaScript 代码也可以使用 focus 事件来为获取焦点的元素添加交互行为，例如：

```javascript
const input = document.getElementById('my-input')

input.addEventListener('focus', function () {
  console.log('input element is now focused')
})
```

上面的代码表示，在输入框元素被聚焦时，将输出一条日志信息。


css - focus


## 文件读写

打开文件

```python
f=open('test.txt','rt')
g=open('test.txt','wt')
```

读取所有内容

```python
data=f.read()
data=f.read([maxbytes])
```

写入内容

```python
g.write('hello world')
```

关闭文件

```python
f.close()
g.close()
```

文件应当在使用完毕后关闭，否则会导致内存泄漏。使用 with 语句可以自动关闭文件。

离开 with 语句后，文件会自动关闭。

```python
with open(filename, 'rt') as file:
    # Use the file `file`
    ...
    # No need to close explicitly
...statements
```

使用`with`语句读取挣个文件

```python
with open('foo.txt', 'rt') as file:
    data = file.read()
```

使用`with`语句按行读取文件

```python
with open('foo.txt', 'rt') as file:
    for line in file:
```

使用`with`语句写入文件

```python
with open('outfile', 'wt') as out:
    out.write('Hello World\n')
```

重定向`print`函数

```python
with open('foo.txt', 'wt') as file:
    print('hello world', file=file)
```


大多数程序需要操作文件，比如读写文件，创建文件夹，删除文件等等。

File Management - 文件读写


Flexbox 是一种 CSS 布局模式，用于在容器中快速、灵活地排列和对齐子元素，可以有效地实现自适应布局和响应式设计。Flexbox 的全称是 Flexible Box Layout，即“弹性盒子布局”。

Flexbox 的核心是容器和子元素之间的关系，容器称为 flex container（弹性容器），子元素称为 flex item（弹性子元素）。通过在容器上设置 display: flex 或 display: inline-flex 属性，可以将容器变为一个 flexbox，然后可以使用一系列的 CSS 属性来控制子元素的排列和对齐方式。

以下是 Flexbox 常用的属性和其作用：

- flex-direction：定义 flex container 的主轴方向，取值包括 row、row-reverse、column 和 column-reverse 四种方向。
- justify-content：定义 flex container 中子元素沿主轴方向的对齐方式，包括 flex-start、flex-end、center、space-between、space-around、space-evenly 六种取值。
- align-items：定义 flex container 中子元素沿交叉轴方向的对齐方式，包括 flex-start、flex-end、center、baseline、stretch 五种取值。
- flex-wrap：定义 flex container 中子元素在一行放不下时如何换行，取值包括 nowrap、wrap 和 wrap-reverse 三种。
- align-content：定义多行子元素在交叉轴方向的对齐方式，仅当 flex-wrap 属性为 wrap 或 wrap-reverse 时生效，包括 flex-start、flex-end、center、space-between、space-around、stretch 六种取值。
- flex-grow：定义子元素的放大比例，如果容器有多余的空间，子元素会按照各自的放大比例分配这些空间。
- flex-shrink：定义子元素的缩小比例，如果容器空间不足，子元素会按照各自的缩小比例缩小。
- flex-basis：定义子元素的基准尺寸，用于计算子元素的放大和缩小比例。
- order：定义子元素的排列顺序，数值越小的子元素越靠前。

Flexbox 的优点是可以简化布局代码，减少使用 float 和 position 的情况，同时可以实现自适应和响应式设计，提高页面的可维护性和可扩展性。但是需要注意的是，Flexbox 不适用于所有场景，例如多行文本的垂直居中需要结合其他技术实现。

以下是一个使用 Flexbox 实现的简单的响应式布局案例，包含一个 header、一个 sidebar 和一个 content 区域，可以根据屏幕尺寸自适应布局：

HTML 代码：

```html
<div class="container">
  <header>Header</header>
  <div class="content">
    <div class="sidebar">Sidebar</div>
    <div class="main">Main content</div>
  </div>
</div>
```

CSS 代码：

```css
.container {
  display: flex;
  flex-wrap: wrap;
}

header {
  width: 100%;
  background-color: #333;
  color: #fff;
  padding: 20px;
  text-align: center;
}

.content {
  display: flex;
  flex-wrap: wrap;
  flex-grow: 1;
  justify-content: flex-start;
  align-items: stretch;
}

.sidebar {
  flex-basis: 200px;
  background-color: #eee;
  padding: 20px;
}

.main {
  flex-grow: 1;
  padding: 20px;
}

@media screen and (max-width: 768px) {
  .sidebar {
    flex-basis: 100%;
  }
}
```

解释：

首先将容器设置为 flex 布局，使用 flex-wrap 属性允许子元素在需要时换行。

- header 元素使用宽度为 100%，背景颜色为深灰色，颜色为白色，使用 padding 属性来增加内边距，使其看起来更美观。

- content 元素作为 flex container，使用 flex-grow 属性让其占据剩余的空间，使用 justify-content 和 align-items 属性分别对子元素进行水平和垂直对齐。

- sidebar 元素使用 flex-basis 属性指定其基准尺寸为 200px，背景颜色为浅灰色，使用 padding 属性增加内边距。

- main 元素使用 flex-grow 属性让其占据剩余的空间，使用 padding 属性增加内边距。

- 在屏幕宽度小于 768px 时，将 sidebar 元素的基准尺寸设置为 100%，让其占据整行宽度。

这个案例展示了 Flexbox 的基本用法，通过简单的 CSS 属性设置，可以实现自适应和响应式布局。

更多请参考：[Flexbox 指南](/blog/css/tips/Flexbox指南)
