css - borders


在 JavaScript 中，继承可以通过构造函数、原型链、实例、拷贝实现。

## 构造继承

构造继承是指创建一个新的对象，并将其父对象的属性和方法复制到新对象上，并对新对象进行初始化。

```js
// 定义父对象
function Person(name, age) {
  this.name = name
  this.age = age
}

Person.prototype.sayHello = function () {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`)
}

// 定义子对象
function Student(name, age, major) {
  Person.call(this, name, age)
  this.major = major
}

// 继承父对象的方法
Student.prototype = Object.create(Person.prototype)
Student.prototype.constructor = Student

// 定义子对象自己的方法
Student.prototype.study = function () {
  console.log(`I am studying ${this.major}.`)
}

const john = new Student('John Doe', 22, 'Computer Science')
john.sayHello()
john.study()
```

在这个示例中，通过将父对象的方法复制到子对象的原型链上，实现了构造继承。

## 原型继承

原型继承通过将子对象的原型指向父对象来实现继承。以下是一个简单的原型继承的例子：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log('My name is ' + this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child

Child.prototype.sayAge = function () {
  console.log('My age is ' + this.age)
}

var child = new Child('John', 25)
child.sayName() // My name is John
child.sayAge() // My age is 25
```

先定义了一个 Parent 函数，它有一个 name 属性和一个 sayName 方法。然后，我们定义了一个 Child 函数，该函数继承了 Parent 函数。我们在 Child 函数中通过调用 Parent.call(this, name) 来初始化 name 属性，并且在 Child.prototype 上添加了一个 sayAge 方法。最后，我们创建了一个 Child 的实例，可以使用继承过来的 sayName 方法和 sayAge 方法。

从 ECMAScript 6 开始，JavaScript 增加了 class 关键字，可以更方便地实现继承。

```js
class Parent {
  constructor(name) {
    this.name = name
  }

  sayName() {
    console.log(this.name)
  }
}

class Child extends Parent {
  constructor(name, age) {
    super(name)
    this.age = age
  }
}

var child = new Child('Tom', 20)
console.log(child.name) // Tom
console.log(child.age) // 20
child.sayName() // Tom
```

## 实例继承

原型链的实现原理是，每个对象都有一个指向它的构造函数的原型的指针，以及一个指向该对象的原型的指针，而原型对象又有自己的原型对象。通过这种方式，所有的对象都构成了一个原型链，我们可以通过在原型对象上定义属性和方法来让它们被所有对象继承。

例如，我们可以定义一个基础对象 Animal，并在其原型对象上定义一个 sayHello 方法：

```js
function Animal() {}
Animal.prototype.sayHello = function () {
  console.log('Hello, I am an animal.')
}
```

然后，我们可以定义一个继承 Animal 的对象 Dog：

```js
function Dog() {}
Dog.prototype = Object.create(Animal.prototype)
Dog.prototype.constructor = Dog
```

现在，我们可以创建一个 Dog 对象并调用 sayHello 方法：

```js
const dog = new Dog()
dog.sayHello() // 输出 "Hello, I am an animal."
```

由此可见，Dog 对象继承了 Animal 的 sayHello 方法。

## 拷⻉继承

拷贝继承是指通过复制一个对象的属性和方法到另一个对象中来实现继承。这种方法主要通过使用一个循环或工具函数，将父对象的属性复制到子对象中。但是，拷贝继承存在一些问题，例如无法在父对象中更改子对象的属性。因此，拷贝继承通常不是首选的继承方法。

以下是一个 JavaScript 拷贝继承的示例：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log(this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

// 将父对象的属性和方法复制到子对象上
for (var prop in Parent.prototype) {
  Child.prototype[prop] = Parent.prototype[prop]
}

var child = new Child('John', 30)
child.sayName() // 输出 'John'
console.log(child.age) // 输出 30
```

在上面的示例中，我们通过循环将父对象的属性和方法复制到了子对象的原型上，从而实现了拷贝继承。

## 原型 prototype 机制或 apply 和 call ⽅法去实现较简单，建议使⽤构造函数与原型混合⽅式

```js
function Parent() {
  this.name = 'wang'
}
function Child() {
  this.age = 28
}
Child.prototype = new Parent() //继承了Parent，通过原型
var demo = new Child()
alert(demo.age)
alert(demo.name) //得到被继承的属性
```


JavaScript 支持继承，这是指在一个对象（称为“子类”）中继承另一个对象的属性和方法（称为“父类”）

继承


Logical Properties 是 CSS3 中引入的一个新特性，它是一个基于逻辑方向的属性系统，主要是为了支持从右向左（RTL）语言的页面设计而引入的。在传统的 CSS 盒模型中，宽度和高度、内边距和边框等属性都是基于物理方向来计算的（如左、右、上、下等），而在 RTL 语言中，这些属性需要根据从右向左的方向来计算。Logical Properties 则提供了一种基于逻辑方向的属性系统，这些属性会自动根据文本的方向进行翻转，从而能够更方便地支持多种语言和布局方式。

Logical Properties 包括以下几种属性：

- inline-size 和 block-size：代表元素的宽度和高度，根据文本的方向而自动调整。
- margin-inline 和 margin-block：代表元素的内边距，也可以用于设置外边距。
- padding-inline 和 padding-block：代表元素的内边距。
- border-inline 和 border-block：代表元素的边框。

其中，inline-size 和 block-size 可以理解为宽度和高度的逻辑属性，可以根据文本方向自动切换。而 margin-inline 和 padding-inline 则代表文本方向上的外边距和内边距，而 margin-block 和 padding-block 则代表块方向上的外边距和内边距。

例如，如果要在一个从右向左的页面中，将一个 div 元素水平居中，可以使用以下代码：

```css
div {
  margin-left: auto;
  margin-right: auto;
  margin-inline-start: 0;
  margin-inline-end: 0;
}
```

在上述代码中，margin-left 和 margin-right 控制了 div 元素的左右外边距，而 margin-inline-start 和 margin-inline-end 控制了 div 元素在文本方向上的外边距，从而实现了水平居中的效果。

需要注意的是，Logical Properties 只在支持 CSS3 的浏览器中才能使用。如果需要在旧版浏览器中使用 Logical Properties，可以考虑使用 Polyfill 或者手动转换为传统的物理属性来实现。


css - Spacing


**df**命令用于显示目前在 Linux 系统上的文件系统磁盘使用情况统计。

## 使用方法

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

同样可以使用**df folder**显示文件夹的使用情况

```bash
df folder
```

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

## 参数

- `-a, --all` 包含所有的具有 0 Blocks 的文件系统
- `--block-size=SIZE` 使用 SIZE 大小的 Blocks
- `-h, --human-readable` 使用人类可读的格式(预设值是不加这个选项的...)
- `-H, --si` 很像 `-h`, 但是用 1000 为单位而不是用 1024
- `-i, --inodes` 列出 inode 资讯，不列出已使用 block
- `-k, --kilobytes` 就像是 `--block-size=1024`
- `-l, --local` 限制列出的文件结构
- `-m, --megabytes` 就像 `--block-size=1048576`
- `--no-sync` 取得资讯前不 sync (预设值)
- `-P, --portability` 使用 POSIX 输出格式
- `--sync` 在取得资讯前 sync
- `-t, --type=TYPE` 限制列出文件系统的 TYPE
- `-T, --print-type` 显示文件系统的形式
- `-x, --exclude-type=TYPE` 限制列出文件系统不要显示 TYPE
- `-v` (忽略)
- `--help` 显示这个帮手并且离开
- `--version` 输出版本资讯并且离开


用于显示目前在 Linux 系统上的文件系统磁盘使用情况统计

Linux命令df


Swift 中复杂类型包括：

- Array
- Set
- Tuple
- Dictionary
- Enums

### Array

> Swift 数组允许您存储相同类型的值，可以使用该值在数组中的位置来检索这些值。Swift 会强制检测元素类型，如果类型不同，会报错。

```swift
// 创建数组
var firstArray = ["hello","hello","world"]
var secondArray = ["swift","niubility"]

// 获取数组第一个元素
print(firstArray[0]) // hello

//添加数组
firstArray.append("manon")
firstArray+=["icu"]

// 循环数组
for item in firstArray{
	print(item) //hell hello world manon icu
}

// 修改数组元素
firstArray[0] = "swift"

// 合并数组
firstArray+secondArray

// 计算数组元素的个数
firstArray.count

// 判断数组是否为空
firstArray.isEmpty

// 删除数组元素
firstArray.remove(at: 0)
```

### Set

> 集合是用来存储类型相同且没有确定顺序的唯一的值，不允许插入已存在的值

```swift
// 创建集合
let firstSet = Set(["hello","world","manon","icu","swift"])
let secondSet = Set(["just","do","it"])

// 访问集合
for item in firstSet{
	print(item) //"hello","world","manon","icu","swift"
}

// 判断是否为空
firstSet.isEmpty // false

// 计算集合的长度
firstSet.count //5

// 判断是否包含某个元素
firstSet.contains("manon") //true

// 向集合添加元素
firstSet.insert("funny")

// 删除集合的元素
firstSet.remove("manon")

// 合并集合
firstSet.union(secondSet)
```

### Tuple

> Swift 中的 tuple 允许存储不同类型的固定数量的值。创建元组后，不能从该元组中添加或删除值。

```swift
// 创建tuple
let firstTuple = (name: "manon", level: 9000, Nationality: "china")

// 访问tuple
firstTuple.name // manon
```

### Dictionary

> Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。 Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。 Swift 字典的 key 没有类型限制可以是整型或字符串，但必须是唯一的。

```swift
// 创建字典
let firstDictionary = ["Gintama" : "Sakata Gintoki", "Haikyuu" : "Shoyo Hinata"]

// 访问字典
firstDictionary["Gintama"] // Sakata Gintoki

// 修改字典
firstDictionary.updateValue("manon",forKey:Gintama)
// 或
firstDictionary["Gintama"] = "manon"

// 删除字典元素
firstDictionary.removeValue("Gintama")

// 遍历字典
for (key,value) in firstDictionary{
	print("字典 key \(key) -  字典 value \(value)")
}

// 计算字典长度
firstDictionary.count

// 判断字典是否为空
firstDictionary.isEmpty
```

### Enums

> 根据 Swift 文档枚举的定义，它是“一组相关值的公共类型，使您能够在代码中以类型安全的方式处理这些值”。可以把它看作是一种特别用于 switch/conditions 的变量类型。

```swift
// 创建Enums
enum enumname {
   // 枚举定义放在这里
}

// 实例

import Cocoa

enum DaysofaWeek {
    case Sunday
    case Monday
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case Saturday
}

var weekDay = DaysofaWeek.THURSDAY
weekDay = .THURSDAY
switch weekDay{
	case .Sunday:
		print("星期天")
	case .Monday:
		print("星期一")
	case .TUESDAY:
		print("星期二")
	case .WEDNESDAY:
		print("星期三")
	case .THURSDAY:
		print("星期四")
	case .FRIDAY:
		print("星期五")
	case .Saturday:
		print("星期六")
}
```


Complex Types - 数组、字典、集合、枚举


## 运行 python

> Python 程序总是在解释器中运行。解释器是一个“基于控制台的”应用程序，通常使用命令运行。

```python
python3
Python 3.9.8 (main, Nov 10 2021, 03:55:42)
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

## 交互模式

当在终端运行`python3`后，就进入了交互模式，即 REPL。

- `>>>`表示开始新的语句
- `...`表示继续上一条语句
- `_`表示最后的返回值

```python
>>> print('hello world')
hello world
>>> 37*42
1554
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>>
```

## 创建程序

> python 程序以`.py`结尾，可以直接运行。

```python
# hello.py
print('hello world')
```

## 运行程序

> python 程序运行的命令是`python hello.py`

```python
$ python hello.py
$ python3 hello.py
```

## 样例程序

> 问题：一天早上，你出去，在芝加哥西尔斯大厦旁的人行道上放了一张美元钞票。从那以后，你每天出去的账单都会翻倍。这堆钞票超过塔的高度需要多长时间？

解决方法：

```python
# sears.py
bill_thickness = 0.11 * 0.001 # Meters (0.11 mm)
sears_height = 442 # Height (meters)
num_bills = 1
day = 1

while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
print('Number of bills', num_bills)
print('Final height', num_bills * bill_thickness)
```

```bash
bash % python3 sears.py
1 1 0.00011
2 2 0.00022
3 4 0.00044
4 8 0.00088
5 16 0.00176
6 32 0.00352
...
21 1048576 115.34336
22 2097152 230.68672
Number of days 23
Number of bills 4194304
Final height 461.37344
```

### 语句

> 每行语句以换行符结束，但是不能以分号结束。

```python
a = 3 + 4
b = a * 2
print(b)
```

### 注释 comment

> 注释以#开始，不会被运行。

```python
a = 3 + 4
# This is a comment
b = a * 2
print(b)
```

### 类型与变量 type&variable

> python 属于动态类型语言，变量可以随时变化。python 变量名称可以包含字母、数字、下划线，但不能以数字或关键字开头。对大小写敏感。

```python
height = 442           # An integer
height = 442.0         # Floating point
height = 'Really tall' # A string

# 大小写敏感
name = 'Jake'
Name = 'Elwood'
NAME = 'Guido'

while x < 0:   # OK
WHILE x < 0:   # ERROR
```

### 循环 for/while

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

### 缩进 indentation

> 缩进是用来表示一组连在一起的语句:

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

- 使用空格代替 tab 来缩进
- 使用 4 个空格来缩进

### 条件语句 if-else

```python
if a > b:
    print('Computer says no')
elif a == b:
    print('Computer says yes')
else:
    print('Computer says maybe')
```

### 输出语句 print

```python
print('Hello world!') # Prints the text 'Hello world!'

#用户输出
name = input('Enter your name:')
print('Your name is', name)
```


First Program - 第一个程序


`string_decoder`用于把 Buffer 转换为字符串

## 基本用法

```js
const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')
const buffer = Buffer.from('Hello World')
const str = decoder.write(buffer)
console.log(str)
```

## 方法

- stringDecoder.write(buffer[, encoding])
- stringDecoder.end(buffer[, encoding])

`write`方法把 buffer 转换为字符串，`end`方法把 buffer 转换为字符串并返回。

```js
const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')

decoder.write(Buffer.from([0xe2]))
decoder.write(Buffer.from([0x82]))
console.log(decoder.end(Buffer.from([0xac])))
```


string_decoder用于把Buffer转换为字符串