css - flexbox


## 字符串文本

> 字符串文本通常是由单引号或者双引号括起来的。通常单行单引号，多行三引号。

```python
# Single quote
a = 'Yeah but no but yeah but...'

# Double quote
b = "computer says no"

# Triple quotes
c = '''
Look into my eyes, look into my eyes, the eyes, the eyes, the eyes,
not around the eyes,
don't look around the eyes,
look into my eyes, you're under.
'''
```

## 字符串转义

```python
'\n'      # 换行
'\r'      # 回车
'\t'      # 水平制表符
'\''      # 单引号
'\"'      # 双引号
'\\'      # 反斜杠
```

## 字符串运算

```python
+  # 字符串连接
*  # 重复
[] # 取子串
[:] # 截取字符串的一部分
in # 判断字符串是否包含某个字符串
not in # 判断字符串是否不包含某个字符串
r/re # 匹配字符串
% # 格式化字符串


a = "Hello"
b = "Python"

print "a + b 输出结果：", a + b
print "a * 2 输出结果：", a * 2
print "a[1] 输出结果：", a[1]
print "a[1:4] 输出结果：", a[1:4]

if( "H" in a) :
    print "H 在变量 a 中"
else :
    print "H 不在变量 a 中"

if( "M" not in a) :
    print "M 不在变量 a 中"
else :
    print "M 在变量 a 中"

print r'\n'
print R'\n'
```

## 字符串方法

```python
s = ' Hello'
t = s.strip() #'Hello'去除空格
l = s.lower() #' hello' 全部转换为小写
u = s.upper() #' HELLO' 全部转换为大写
c = s.capitalize() #'Hello' 字符串首字母大写
t = s.replace('H', 'J') #'Jello' 将所有的H替换为J

s.endswith(suffix)     # 判断字符串是否以指定后缀结尾
s.find(t)              # 查找字符串中指定字符或字符串的索引位置
s.index(t)             # 查找字符串中指定字符或字符串的索引位置
s.isalpha()            # 判断字符串是否只有字母
s.isdigit()            # 判断字符串是否只有数字
s.islower()            # 判断字符串是否只有小写
s.isupper()            # 判断字符串是否只有大写
s.join(slist)          # 将字符串s与字符串列表slist中的字符串连接
s.lower()              # 转换字符串中所有大写字符为小写
s.replace(old,new)     # 替换字符串中的指定字符串
s.rfind(t)             # 从右边开始查找字符串中指定字符或字符串的索引位置
s.rindex(t)            # 从右边开始查找字符串中指定字符或字符串的索引位置
s.split([delim])       # 将字符串分割成一个列表
s.startswith(prefix)   # 判断字符串是否以指定前缀开头
s.strip()              # 去掉字符串左右两边的空格
s.upper()              # 转换字符串中的小写字母为大写
```

## 字符串类型转换

> 使用`str()`将任何值转换成字符串

```python
x=42
str(x) #'42'
```

## 其他字符类型

```python
# 字节类型
data = b'Hello World\r\n'
len(data)                         # 13
data[0:5]                         # b'Hello'
data.replace(b'Hello', b'Cruel')  # b'Cruel World\r\n'

# Raw字节类型
>>> rs = r'c:\newdata\test' # Raw (uninterpreted backslash)
>>> rs
'c:\\newdata\\test'

# f-string
>>> name = 'IBM'
>>> shares = 100
>>> price = 91.1
>>> a = f'{name:>10s} {shares:10d} {price:10.2f}'
>>> a
'       IBM        100      91.10'
>>> b = f'Cost = ${shares*price:0.2f}'
>>> b
'Cost = $9110.00'
>>>
```


Strings - 字符类型


Swift 有三种循环：

- for
- while
- repeat

## for 循环

> 用来重复执行一系列语句直到达成特定条件，如下图：

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

```swift
// 语法
for init; condition; increment{
   // do something
}

// example
let albums = ["Red", "1989", "Reputation"]
for album in albums {
    print("\(album) is on Apple Music")
}
```

## while 循环

> while 循环从计算单一条件开始。如果条件为 true，会重复运行一系列语句，直到条件变为 false。

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

```swift
// 语法
while condition{
   // do something
}
// example
var number = 1

while number <= 20 {
    print(number)
    number += 1
}

print("Ready or not, here I come!")
```

## repeat 循环

> repeat...while 循环不像 for 和 while 循环在循环体开始执行前先判断条件语句，而是在循环执行结束时判断条件是否符合。 `repeat...while无论条件是否符合，循环会执行至少一次`

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

```swift
// 语法
repeat{
   statement(s);
}while( condition );

// example
var number = 1

repeat {
    print(number)
    number += 1
} while number <= 20

print("Ready or not, here I come!")
```

## 退出循环

使用`break`退出循环语句，比如在 while 循环中：

```swift
while countDown >= 0 {
    print(countDown)

    if countDown == 4 {
        print("I'm bored. Let's go now!")
		// 当countDown等于4的时候会退出循环
        break
    }

    countDown -= 1
}
```

## 退出多重循环

在嵌套循环中，想要同时打破内循环和外循环是很常见的。举个例子，我们可以编写一些代码来计算从 1 到 10 的乘法表，如下所示:

```swift
for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

如果需要退出这个双重循环，需要做两步，首先，给外循环加上 label:`outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

第二步，在内循环执行`break outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")

        if product == 50 {
            print("It's a bullseye!")
            break outerLoop
        }
    }
}
```

## 跳过条件 - continue

> `break`退出循环。但是，如果只想跳过当前条件，继续下一个条件，应该使用`continue`。比如如下跳过奇数：

```swift
for i in 1...10 {
    if i % 2 == 1 {
        continue
    }

    print(i)
}
```


Looping - 循环


## 闭包的定义

闭包(Closures)是自包含的功能代码块，可以将闭包视为无名函数，可以将其分配给变量或将其作为参数传递给函数。
闭包主要用于在将来满足条件时执行某项操作。例如，成功下载文件后，将其内容存储到数据库中。

全局函数和嵌套函数其实就是特殊的闭包。

闭包的形式有：

| 全局函数               | 嵌套函数                       | 闭包表达式                                         |
| ---------------------- | ------------------------------ | -------------------------------------------------- |
| 有名字但不能捕获任何值 | 有名字，也能捕获封闭函数内的值 | 无名闭包，使用轻量级语法，可以根据上下文环境捕获值 |

## 创建闭包

```swift
let helloWorldClosure = {
  print("hello")
}

helloWorldClosure()
```

上面的代码创建一个打印`Hello`的闭包，并将该闭包分配给`helloWorldClosure`变量。然后，可以像调用函数一样简单地调用闭包。

## 接收参数

```swift
let driving = { (place: String) in
    print("I'm going to \(place) in my car")
}
driving("London")
```

## 闭包返回值

```swift
let addClosure = { (first: Int, second: Int) -> Int in
    return first + second
}

let sum = addClosure(1,2)
```

上面的代码创建一个以两个数字为参数的闭包，并返回数字的总和。

## 作为参数传递

```swift
let saveFile = {
   //code to save file
}

func downloadFile(imageUrl, onSuccess: () ->) {
  //code to download file
  if(downloadSuccessfull){
     onSuccess()
  }
}

downloadFile(imageUrl: "Instagram", onSuccess: saveFile)
```

闭包强制返回值，`()->Void`表示不接受参数并且不返回任何内容。可以将`Void`替换为任何类型，如`Int`或者`String`，强制闭包返回值。

```swift
func travel(action: (String) -> String) {
    print("I'm getting ready to go.")
    let description = action("London")
    print(description)
    print("I arrived!")
}

travel { (place: String) -> String in
    return "I'm going to \(place) in my car"
}

# 闭包简写
travel {
    return "I'm going to \($0) in my car"
}

# 多参数传递
func travel(action: (String, Int) -> String) {
    print("I'm getting ready to go.")
    let description = action("London", 60)
    print(description)
    print("I arrived!")
}

travel {
    return "I'm going to \($0) at \($1) in my car"
}
```

## 闭包总结

- 可以将闭包赋值给变量
- 闭包接收参数和返回值
- 可以将闭包作为参数传递到函数中，这些闭包可以有自己的参数和返回值。
- 如果函数的最后一个参数是闭包，则可以使用尾随闭包语法。
- Swift 自动提供速记参数名称，如$0 和$1，但并非所有人都使用它们。
- 如果在闭包中使用外部值，它们将被捕获，以便闭包稍后可以引用它们。


闭包(Closures)是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。

Closures - 闭包


`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


`zlib`模块提供通过 `Gzip` 和 `Deflate/Inflate` 实现的压缩功能

## 创建和使用压缩流

```js
const zlib = require('zlib')
const gzip = zlib.createGzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt')
const out = fs.createWriteStream('input.txt.gz')
inp.pipe(gzip).pipe(out)
// 在桌面创建 input.txt 和 input.txt.gz 文件
```

## 解压缩和创建文件

```js
const zlib = require('zlib')
const gunzip = zlib.createGunzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt.gz')
const out = fs.createWriteStream('input.txt')
inp.pipe(gunzip).pipe(out)

// 在桌面创建 input.txt 和 input.txt.gz 文件
```

```

```


zlib模块提供通过 Gzip 和 Deflate/Inflate 实现的压缩功能

Node.js - zlib


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 或者手动转换为传统的物理属性来实现。
