Learning React.js


Swift 是一种适用于 iOS、macOS、watchOS 和 Apple tvOS app 开发的新编程语言。尽管如此，Swift的许多部分将从您在C和Objective-C中开发的经验中熟悉。

Swift提供所有基本C和Objective-C类型的版本，包括用于整数的Int、用于浮点值的Double和Float、用于布尔值的Bool和用于文本数据的String。Swift还提供了三种主要集合类型的强大版本，例如Array、Set和Dictionary，如Collection Types中所述。

与C一样，Swift使用变量通过标识名称存储和引用值。Swift还广泛使用其值无法更改的变量。这些被称为常数，比C中的常数强大得多。当您处理不需要更改的值时，整个Swift都使用常量，以使代码的意图更安全、更清晰。

除了熟悉的类型外，Swift还引入了Objective-C中没有的高级类型，例如元组。元组使您能够创建和传递值分组。您可以使用元组将函数中的多个值作为单个复合值返回。

Swift还引入了可选类型，用于处理缺少值的情况。可选的说“有一个值，它等于x”或“根本没有值”。使用可选选项类似于在Objective-C中使用带有指针的nil，但它们适用于任何类型，而不仅仅是类。可选选项不仅比Objective-C中的nil指针更安全、更具表现力，而且是Swift许多最强大功能的核心。

Swift是一种类型安全的语言，这意味着该语言可以帮助您清楚地了解代码可以使用的值类型。如果您的部分代码需要String，类型安全性会阻止您错误地将其传递给Int。同样，类型安全可防止您意外地将可选String传递给需要非可选String的代码。类型安全可帮助您尽早在开发过程中捕获和修复错误。

## 常量和变量

常量和变量将值分配给特定的标识符，以便您可以在代码中引用它们。常量的值一旦设置就无法更改，而变量的值可以更改。

### 声明常量和变量

您可以使用let关键字声明常量，使用var关键字声明变量。常量和变量的名称可以包含任何字符，包括Unicode字符：

```swift
let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0
```

常量和变量的名称不能包含空格、数学符号、箭头、保留的（或者非法的）Unicode代码点、连线和制表符。也不能以数字开头，但可以在名称的其他地方包含数字。

打印常量和变量的值：

```swift
print(maximumNumberOfLoginAttempts)
print(currentLoginAttempt)
```

使用反斜杠（\）将常量和变量的名称放在括号中，以在字符串插值中包含它们的当前值：

```swift
print("Maximum number of login attempts is \(maximumNumberOfLoginAttempts)")
```

### 类型标注

您可以在声明常量或变量时提供类型标注（type annotation），以明确常量或变量可以存储的值的类型。在类型标注后面加上一个冒号和空格，然后加上类型名称，以指定常量或变量可以存储的值的类型：

```swift
var welcomeMessage: String
```

类型标注是一种为常量或变量提供关于其允许存储的值类型的方法。它不会为常量或变量的值分配任何实际的值；它只是说明了常量或变量可以存储的值的类型。如果您在声明常量或变量时提供了类型标注，您可以在该常量或变量的赋值语句中省略对其类型的说明。类型标注的使用可以使您的代码更具可读性，因为它允许您立即知道常量或变量可以存储的值的类型。

## 注释

您可以使用单行注释（single-line comments）将注释嵌入到代码中。单行注释以两个正斜杠（//）开头：

```swift
// This is a comment
```

您可以使用多行注释（multi-line comments）将注释嵌入到代码中。多行注释以正斜杠后跟星号（/*）开头，以星号后跟正斜杠（*/）结尾：

```swift
/* This is also a comment
but is written over multiple lines. */
```

## 分号

Swift不要求您在每个语句结尾处使用分号（;），但是您可以使用分号将多个独立的语句写在同一行上：

```swift
let cat = "🐱"; print(cat)
```

## 整数

整数是没有小数部分的数字，例如42和-23。Swift提供了8、16、32和64位有符号和无符号整数类型。这些整数类型的名称与它们的位数相同，例如UInt8表示8位无符号整数，Int32表示32位有符号整数。

整数范围：

```swift
let minValue = UInt8.min
let maxValue = UInt8.max
```

## 浮点数

浮点数是有小数部分的数字，例如3.14159、0.1和-273.15。Swift提供了两种有符号的浮点数类型：

- Double表示64位浮点数。
- Float表示32位浮点数。

如果您需要在您的代码中选择浮点数类型，推荐使用Double类型，除非你特别需要它的性能。

## 类型安全和类型推断

Swift是一种类型安全（type-safe）语言。类型安全语言可以让您清楚地知道代码可以处理的值的类型。如果部分代码期望得到String，您就不能传递一个Int来代替。

Swift通过类型推断（type inference）来选择合适的类型。如果您没有明确指定类型，Swift使用类型推断来选择合适的类型。例如，如果您给一个新的浮点值赋值，Swift会推断您想要创建一个Double而不是Float：

```swift
let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int
let pi = 3.14159
// pi is inferred to be of type Double
```

如果您在一行中声明多个同类型的值，您可以在一行中写出所有值，用逗号隔开，Swift会自动推断出这些值的类型：

```swift
let x = 0.0, y = 0.0, z = 0.0
```

## 数值型字面量

整数字面量可以被写作：

- 一个十进制数，没有前缀
- 一个二进制数，前缀是0b
- 一个八进制数，前缀是0o
- 一个十六进制数，前缀是0x

十进制数的例子：

```swift
let decimalInteger = 17
let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation
```

浮点字面量可以是十进制（没有前缀），或者是十六进制（前缀是0x）。十进制浮点字面量还可以有一个可选的指数（exponent），通过大写或小写的e来指定。十六进制浮点字面量必须有一个指数；指数通过大写或小写的p来指定。十进制浮点字面量的例子：

```swift
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0
```

## 数值型类型转换

整数和浮点数类型转换必须显式指定类型：

```swift
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
// twoThousandAndOne is equal to 2001
```

## 类型别名

类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

```swift
typealias AudioSample = UInt16
var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0
```

## 布尔值

Swift有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift提供两个布尔常量，true和false：

```swift
let orangesAreOrange = true
let turnipsAreDelicious = false
```

## 元组

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

```swift
let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")
```

元组的内容可以分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：

```swift
let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// Prints "The status code is 404"
print("The status message is \(statusMessage)")
// Prints "The status message is Not Found"
```

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：

```swift
let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)")
// Prints "The status code is 404"
```

你也可以通过下标来访问元组中的单个元素，下标从零开始：

```swift
print("The status code is \(http404Error.0)")
// Prints "The status code is 404"
print("The status message is \(http404Error.1)")
// Prints "The status message is Not Found"
```

你可以在定义元组的时候给单个元素命名：

```swift
let http200Status = (statusCode: 200, description: "OK")
```

这个元组的名字叫做http200Status，它的类型是(Int, String)。你可以通过名字来获取元素的值：

```swift
print("The status code is \(http200Status.statusCode)")
// Prints "The status code is 200"
print("The status message is \(http200Status.description)")
// Prints "The status message is OK"
```

## 可选类型

Swift的可选类型（optional types）表示：

* 这个值可能有值，等于x
* 这个值可能没有值

可选类型有点像Objective-C中的nil指针，但是它们可以用于任何类型，不仅仅是类。可选类型表示的是值缺失，而不是值为nil。这样的设计可以让你避免在你的代码中使用nil值。


## 可选绑定

可选绑定（optional binding）用来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或变量。

```swift
if let constantName = someOptional {
    statements
}
```

## 隐式解析可选类型

有时候在变量的生命周期中，会确定一个可选类型变量总会有值。在这种情况下，每次都需要判断和解析可选值是非常麻烦的。这时候可以选择隐式解析可选类型（implicitly unwrapped optionals）。

```swift
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation point

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // no need for an exclamation point
```

## 错误处理

Swift提供了一种在运行时表示和抛出错误的机制。这个机制让你能够表示和抛出你自己的错误，并且把函数抛出的错误传递到程序的某个地方。

```swift
enum VendingMachineError: ErrorType {
    case InvalidSelection
    case InsufficientFunds(coinsNeeded: Int)
    case OutOfStock
}

throw VendingMachineError.InsufficientFunds(coinsNeeded: 5)
```

## 断言和先决条件

断言和先决条件用来检查在运行时一个必要的条件是否为真。如果条件判断的结果为true，代码继续运行。如果条件判断的结果为false，代码执行结束，你的应用被终止。

```swift
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// This assertion fails because -3 is not >= 0.

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}
// Prints "You can ride the ferris wheel."
```




Swift是一种适用于iOS、macOS、watchOS和tvOS应用程序的编程语言。

Swift - 基础知识


## 字符串的定义：

Swift 中可以使用两种方式来定义字符串：

- 使用双引号("")将字符串括起来。
- 使用三个双引号(""")来定义多行字符串。
  例如：

```swift
let str1 = "Hello, world!" // 使用双引号定义字符串
let str2 = """
This is a
multi-line
string.
""" // 使用三个双引号定义多行字符串
```

Swift 中的字符类型（Character）表示一个单独的字符，通常用于表示一个字母、数字、符号或空格等单个文本字符。

## 字符的定义：

Swift 中使用单引号('')来定义字符，例如：

```swift
let char1: Character = "A" // 定义单个字符
```

在字符串中，可以使用字符的集合来表示一段文本。例如：

```swift
let str3 = "Swift"
for char in str3 {
print(char)
}
```

上述代码会输出字符串 "Swift" 中的每个字符，即 "S"、"w"、"i"、"f"、"t"。

Swift 中的字符串和字符类型还支持各种文本处理功能，例如拼接、截取、查找、替换、转换大小写等。这些功能可通过使用字符串和字符类型的内置方法和属性来实现。

以下是一些常见的字符串和字符处理方法和属性的示例：

## 字符串拼接

可以使用加号运算符（+）将两个字符串连接起来。例如：

```swift
let str1 = "Hello"
let str2 = "world"
let str3 = str1 + " " + str2 // "Hello world"
```

## 字符串截取

可以使用下标操作符([])和 range(范围)操作符(...和..\<)从字符串中截取一段子字符串。例如：

```swift
let str = "Hello, world!"
let subStr1 = str[..<5] // "Hello"
let subStr2 = str[7...] // "world!"
let subStr3 = str[7..<12] // "world"
```

## 字符串查找

可以使用内置的 contains() 方法查找字符串是否包含某个子字符串，也可以使用 range(of: String) 方法查找子字符串的范围。例如：

```swift
let str = "Hello, world!"
let hasWorld = str.contains("world") // true
let range = str.range(of: "world") // Range<String.Index>(7..<12)
```

## 字符串替换

可以使用 replaceSubrange() 方法替换字符串中的一段子字符串。例如：

```swift
var str = "Hello, world!"
str.replaceSubrange(7..<12, with: "Swift") // "Hello, Swift!"
```

## 字符串大小写转换

可以使用 uppercased() 方法将字符串中的所有字符转换为大写，使用 lowercased() 方法将其转换为小写。例如：

```swift
let str = "Hello, world!"
let upperStr = str.uppercased() // "HELLO, WORLD!"
let lowerStr = str.lowercased() // "hello, world!"
```

## 字符串和数字类型的相互转换

可以使用 String() 方法将数字类型转换为字符串，使用 Int()、Float() 或 Double() 等方法将字符串转换为相应的数字类型。例如：

```swift
let num = 123
let str = String(num) // "123"

let str2 = "3.14"
let floatNum = Float(str2) // 3.14
```


字符串（String）是一种用于存储和操作文本的类型。字符串由一系列字符（Character）组成，可以包含字母、数字、符号和空格等文本字符。Swift 的字符串类型是可变的（Mutable），可以修改其值。

Swift - 字符、字符串


## 如何运行容器

在[Hello world](/blog/docker/hello-world)中我们已经介绍了如何运行一个容器，这里我们再来详细介绍一下如何运行一个容器。

运行 docker 容器基本命令

```bash
docker run <image name>
```

详细命令

```bash
docker <object> <command> <options>
```

- object: 对象，可以是容器、镜像、网络、卷等
- command: 命令，可以是运行、创建、删除、停止等
- options: 选项，可以是镜像名、容器名、网络名等

```bash
docker container run <image name>
```

image name 可以是镜像 ID、镜像名、镜像名:tag，例如：

```bash
docker container run --publish 8080:80 nginx
```

## 如何发布端口

容器是独立的环境。您的主机系统对容器内发生的事情一无所知。因此，在容器内运行的应用程序仍然不能从外部访问。

要允许从容器外部访问，必须将容器内的适当端口发布到本地网络上的端口。`--publish`或`-p` 选项的常用语法如下:

```bash
docker container run --publish <host port>:<container port>
```

host port: 主机端口，可以是任意端口，例如 8080

container port: 容器端口，可以是容器内部的任意端口，例如 80

通过上面的命令，我们可以将容器内的 80 端口发布到主机的 8080 端口，这样我们就可以通过主机的 8080 端口访问容器内的 80 端口了。

默认情况下，`docker container run` 命令会在前台运行容器。这意味着，您的终端会被占用，直到您按下 Ctrl+C 停止容器。

## 如何使用分离模式

docker 分离模式可以让我们在后台运行容器，这样我们就可以在终端执行其他命令了。

```bash
docker container run --publish 8080:80 --detach nginx
```

## 如何列出容器

`container ls` 命令可以列出所有正在运行的容器。

```bash
docker container ls

# CONTAINER ID        IMAGE                 COMMAND                  CREATED             STATUS              PORTS                  NAMES
# 9f21cb777058        fhsinchy/hello-dock   "/docker-entrypoint.…"   5 seconds ago       Up 5 seconds        0.0.0.0:8080->80/tcp   gifted_sammet
```

名称为 gifted_sammet 的容器正在运行，创建于 5 秒前，状态是`Up 5 seconds`。CONTAINER ID 是 9f21cb777058，镜像是 fhsinchy/hello-dock，端口是 8080:80。

## 如何命名或重命名容器

`--name` 选项可以为容器命名。

```bash
docker container run --publish 8080:80 --detach --name webhost nginx
```

CONTAINER ID 是随机的 64 位字符串，如果您想要为容器命名，可以使用`--name`选项。

```bash
docker container run --detach --publish 8888:80 --name hello-dock-container fhsinchy/hello-dock

# b1db06e400c4c5e81a93a64d30acc1bf821bed63af36cab5cdb95d25e114f5fb
```

使用`container rename`重命名已经存在的容器。

```bash
docker container rename hello-dock-container hello-dock
```

## 如何停止或终止正在运行的容器

使用`docker stop`命令终止正在运行的容器。比如：

```bash
docker stop container_name_or_ID
```

如果容器未终止，可以使用`docker kill <container name or container id>`杀掉容器。

```bash
docker kill <container_name_or_ID>
```

停止或终止容器可能会丢失任何未保存的数据或状态。

## 如何重启容器

使用`docker restart`重启容器，例如：

```bash
docker restart container_name_or_id
```

这将停止容器，然后使用与前面相同的配置重新启动它。适用于对容器的环境变量、网络设置应用更改时，或者当容器由于错误而停止时。

## 如何在不运行的情况下创建容器

- container create 命令创建容器，但不启动它。

```bash
docker container create --publish 80:80 --name webhost nginx
```

- container start 命令启动容器，需要先创建容器。

```bash
docker container start webhost
```

## 如何删除容器

删除已经停止的容器，使用`docker container rm`命令。

```bash
docker container rm container_name_or_id
```

通过 container ls --all 命令可以列出所有容器，其中 status 为 exited 的容器是已经停止的容器。

```bash
docker container ls --all
```

## 如何以交互模式运行容器

要以交互模式运行容器，可以使用 docker run 命令并在命令末尾加上 -it 选项。例如：

```bash
docker run -it image_name /bin/bash
```

这将启动一个新的容器，并以交互模式运行 /bin/bash。这对于进入容器内部并执行命令非常有用。

## 如何在容器内执行命令

使用 docker exec 命令在容器内执行命令。语法如下：

```bash
docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
```

例如，要在容器内部运行 ls 命令，可以使用以下命令：

```bash
docker exec container_name_or_id ls
```

## 如何使用可执行镜像

可执行映像是包含可执行二进制文件或脚本的映像，它被设计为作为独立进程运行。要处理可执行映像，需要使用`docker run`命令。基本语法是:

```bash
docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]
```

例如：运行名称为 hello-dock 的可执行镜像，可以使用以下命令：

```bash
docker run hello-dock
```

如果在 Dockerfile 中指定了 默认命令，可以使用以下命令：

```bash
docker run hello-dock
```

否则，可以使用以下命令：

```bash
docker run hello-dock /bin/bash
```

同样，可以使用命令传递参数：

```bash
docker run hello-dock /bin/bash -c "echo hello world"
```

## 如何忽略不必要的文件

在 Dockerfile 中，可以使用 .dockerignore 文件来忽略不必要的文件。例如，如果 Dockerfile 位于项目根目录中，可以使用以下命令忽略所有 .git 文件：

```bash
echo ".git" >> .dockerignore
```


Docker 容器基本操作


## 总览

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

- 股票池
- 股票价格

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

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

## 列表

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

```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 - 集合


CSS（Cascading Style Sheets）是一种用于网页样式设计的语言。通过 CSS 样式表，可以控制网页中元素的颜色、大小、位置、字体、背景等外观样式，使得网页在视觉效果上更加美观和易于阅读。

下面是一些 CSS 的基本概念和语法：

1. 选择器
   选择器是用于选择网页中的元素的名称或标识符，例如标签名、类名、ID 等。选择器用于定义需要应用样式的元素。下面是一些常见的选择器：

标签选择器：使用 HTML 元素的标签名作为选择器，例如 p、h1、div 等。
类选择器：使用 .class 作为选择器，例如 .header、.content、.footer 等。
ID 选择器：使用 #id 作为选择器，例如 #logo、#nav 等。
属性选择器：使用元素的属性作为选择器，例如 [type="text"]、[href] 等。
伪类选择器：使用元素的特定状态作为选择器，例如 :hover、:active、:focus 等。

2. 属性和值
   属性是用于控制网页元素外观的特定属性，例如字体、颜色、大小、边框等。属性值用于设置属性的具体值，例如字体类型、颜色代码、像素值等。

例如，以下代码中的 color 属性设置文字颜色，font-size 属性设置文字大小：

```css
p {
  color: red;
  font-size: 16px;
}
```

3. 注释
   CSS 中的注释用于在样式表中添加注释或说明，这些注释不会被浏览器解析或显示在网页中。注释使用 /_ ... _/ 的语法。

```css
/* 这是一条注释 */
p {
  color: blue;
}
```

4. 层叠和继承
   CSS 中的层叠和继承是两个重要的概念。

层叠指的是当一个元素被多个选择器选中时，浏览器会按照一定的规则决定哪些样式将被应用到该元素上。这些规则包括选择器的特殊性、选择器的位置等。

继承指的是当一个元素应用样式时，它的子元素也会继承这些样式。例如，如果给 body 元素设置了字体大小，那么网页中的所有子元素都会继承这个字体大小，除非它们自己定义了字体大小。

5. [盒模型](/blog/css/01-Box20%Model)


css样式表是一种用于网页样式设计的语言。通过CSS样式表，可以控制网页中元素的颜色、大小、位置、字体、背景等外观样式，使得网页在视觉效果上更加美观和易于阅读。

css -  样式表


> 引用类型是把数据和功能组织在一起的结构

## 原始包装类型

### Boolean

Boolean 有两个值 true/false。

| 数据类型  | 转换为 true 的值 | 转换为 false 的值 |
| --------- | ---------------- | ----------------- |
| Boolean   | true             | false             |
| String    | 任意飞空字符串   | 空字符串          |
| Number    | 任何非零值       | 0 和 NaN          |
| Object    | 任何对象         | null              |
| Undefined |                  | undefined         |

### Number

```js
const age = 36
typeof age //number

const age = Number(36)
typeof age //number

//使用new声明的Number返回object类型，可使用valueOf获取原始值
const age = new Number(36)
typeof age //object
```

#### 属性

1. EPSILON - 两个数字之间的最小间隔
2. MAX_SAFE_INTEGER - 可表示的最大整数值
3. MAX_VALUE - 可表示的最大正值
4. MIN_SAFE_INTEGER - 可表示的最小整数值
5. MIN_VALUE - 可表示的最小正值
6. NAN - not a number
7. NEGATIVE_INFINITY - 正向无穷大
8. POSITIVE_INFINITY - 负向无穷大

```js
Number.EPSILON //2.220446049250313e-16
Number.MAX_SAFE_INTEGER //9007199254740991
Number.MAX_VALUE //1.7976931348623157e+308
Number.MIN_SAFE_INTEGER //-9007199254740991
Number.MIN_VALUE //5e-324
Number.NAN //NaN
Number.NEGATIVE_INFINITY //-Infinity
Number.POSITIVE_INFINITY //Infinity
```

#### 方法

- Number.isNaN(value) //当 value 为非 number 时返回 true
- Number.isFinite(value) //当 value 是有穷值返回 true
- Number.isInteger(value) //当 value 是整型值返回 true
- Number.isSafeInteger(value) //当 value 是安全整型值返回 true
- Number.parseFloat(value) //将值转换成浮点类型并返回
- Number.parseInt(value) //将值转换成整形并返回

#### 实例方法

当使用 new 关键词声明一个数值，将会返回 object，并且提供如下方法。

```js
const age = new Number(36)
typeof age //object
```

- .toExponential() //将值转换成指数计数法
- .toFixed() //返回小数点后 N 位
- .toLocaleString() //将值转换成字符类型
- .toPrecision() //返回指定的精度
- .toString() //将值转换成字符类型
- .valueOf() //返回原始值

### String

- String.fromCharCode() //通过一串 Unicode 创建字符串。
- String.fromCodePoint() //通过一串 码点 创建字符串。
- String.raw() //通过模板字符串创建字符串。

#### 实例方法

- charAt(i)
- charCodeAt(i)
- codePointAt(i)
- concat(str)
- endsWith(str)
- includes(str)
- indexOf(str)
- lastIndexOf(str)
- localeCompare()
- match(regex)
- normalize()
- padEnd()
- padStart()
- repeat()
- replace(str1, str2)
- search(str)
- slice(begin, end)
- split(separator)
- startsWith(str)
- substring()
- toLocaleLowerCase()
- toLocaleUpperCase()
- toLowerCase()
- toString()
- toUpperCase()
- trim()
- trimEnd()
- trimStart()
- valueOf()

#### charAt

> 返回指定位置的字符,且返回的字符长度为 1，**_js 没有一种有别于字符串类型的字符数据类型_**

```js
string.charAt(index)

'porhub'.charAt(0) //'p'
'porhub'.charAt(1) //'o'
'porhub'.charAt(2) //'r'
```

#### charCodeAt

> 返回在指定的位置的字符的 Unicode 编码

**字符串中第一个字符的下标是 0。如果 index 是负数，或大于等于字符串的长度，则 charCodeAt() 返回 NaN。**

```js
string.charCodeAt(index)

'porhub'.charCodeAt(0) //112
'porhub'.charCodeAt(1) //111
'porhub'.charCodeAt(2) //114
```

#### codePointAt

> ES2015 引入的，用于处理 2 UTF-16 字符的，比如中文，在 ES2015 之前 charCodeAt 只能处理单个字符，处理双字符必须一个个处理然后拼接。

```js
string.codePointAt(index)

//ES2015之前
'𠮷'.charCodeAt(0).toString(16) //d842
'𠮷'.charCodeAt(1).toString(16) //dfb7
;('\ud842\udfb7') //𠮷

//ES2015
'𠮷'.codePointAt(0) //20bb7
;('\u{20bb7}') //𠮷
```

#### concat

> 类似 Array 的 concat

```js
stringObject.concat(stringX,stringX,...,stringX)

"browser".concat("porhub");
```

通常使用 + 拼接来得更方便，或者使用 ES2015 的``字符扩展。

#### endWith

> 用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。

```js
str.endsWith(searchString, position)

'JavaScript'.endsWith('Script') //true
'JavaScript'.endsWith('script') //false
'JavaScript'.endsWith('Script', 5) //false
'JavaScript'.endsWith('as', 5) //true
```

#### includes

> 用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false

```js
str.includes(searchString, position)

'JavaScript'.includes('Script') //true
'JavaScript'.includes('script') //false
'JavaScript'.includes('nice') //true
'JavaScript'.includes('nice', 3) //false
```

#### indexOf

> 用于返回字符串中出现某个字符的初始位置，如果没有找到，返回-1.

```js
str.indexOf(searchString, startPosition)

'JavaScript'.indexOf('a') //1
'JavaScript'.indexOf('a', 2) //3
```

#### lastIndexOf

> 用于返回某个字符最后出现的位置，如果没有，返回-1

```js
str.lastIndexOf(searchString, startPosition)

'JavaScript'.lastIndexOf('a') //3
'JavaScript'.lastIndexOf('a', 1) //1
```

#### padEnd

> 用一个字符串填充当前字符串（如果需要的话则重复填充），返回填充后达到指定长度的字符串。从当前字符串的末尾（右侧）开始填充。

```js
str.padEnd(targetLength, string)

'abc'.padEnd(10) // "abc       "
'abc'.padEnd(10, 'foo') // "abcfoofoof"
'abc'.padEnd(6, '123456') // "abc123"
'abc'.padEnd(1) // "abc"
```

#### padStart

> 用另一个字符串填充当前字符串(重复，如果需要的话)，以便产生的字符串达到给定的长度。填充从当前字符串的开始(左侧)应用的

```js
str.padStart(targetLength, string)

'abc'.padStart(10) // "       abc"
'abc'.padStart(10, 'foo') // "foofoofabc"
'abc'.padStart(6, '123465') // "123abc"
'abc'.padStart(8, '0') // "00000abc"
'abc'.padStart(1) // "abc"
```

#### repeat

> 构造并返回一个包含被连接在一起的指定数量的新字符串。

```js
str.repeat(count)

'abc'.repeat(-1) // RangeError: repeat count must be positive and less than inifinity
'abc'.repeat(0) // ""
'abc'.repeat(1) // "abc"
'abc'.repeat(2) // "abcabc"
'abc'.repeat(3.5) // "abcabcabc" 参数count将会被自动转换成整数.
'abc'.repeat(1 / 0) // RangeError: repeat count must be positive and less than inifinity
```

#### slice

> 截取字符串的一部分，并返回一个新的字符串

```js
str.slice(startPosition, endPosition)

'abc'.slice(0, 1) //a
'abc'.slice(0, -1) //ab
```

#### split

> 将字符串切割成数组

```js
str.split(separator, limit)

'abc'.split() //"[a,b,c]";
'a,b,c'.split(',', 1) //[a]
```

#### startWith

> 判断字符串是否以给定的字符串开始，返回 true/false

```js
str.startsWith(searchString, poistion)

'abc'.startsWith('a') //true
'abc'.startsWith('a', 1) //false
```

#### substring

> 根据开始索引到结束索引截取字符串

```js
str.substring(startPosition, endPosition)

'abc'.substring(0, 1) //a
'abc'.substring(-1) //abc
```

1. 如果 startPosition 等于 indexEnd，substring 返回一个空字符串。
2. 如果省略 indexEnd，substring 提取字符一直到字符串末尾。
3. 如果任一参数小于 0 或为 NaN，则被当作 0。
4. 如果任一参数大于 stringName.length，则被当作 stringName.length。
5. 如果 startPosition 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。

### toLocaleLowerCase/toLocaleUpperCase/toUpperCase/toLowerCase

> 将字符串转换成小写/大写

```js
str.toLocaleLowerCase() /
  str.toLocaleUpperCase() /
  str.toUpperCase() /
  str.toLowerCase()

'ABC'.toLocaleLowerCase() //abc
'abc'.toLocaleUpperCase() //ABC
```

#### toString

> 将\*转换成字符串

```js
var x = new String('Hello world')

alert(x.toString()) // 输出 "Hello world"
```

#### trim/trimStart/trimEnd

> 移除空白字符/起始位置空白字符/结尾位置空白字符

```js
str.trim() / str.trimStart() / str.trimEnd()

'Testing'.trim() //'Testing'
' Testing'.trim() //'Testing'
' Testing '.trim() //'Testing'
'Testing '.trim() //'Testing'
```

#### valueOf

> 返回 str 的原始值，等同于 String.prototype.toString

```js
str.valueOf()

x = new String('Hello world')
alert(x.valueOf()) // Displays "Hello world"
```

#### 扩展学习

```js
1 +
  '5'[(1, 3, 5)] + //"15"
  1 //"1,3,51"
10 + true // 11
15 + {} // "15[object Object]"
8 + null // 8
'queen' + null // "queennull"
12 + undefined // NaN
```

[See examples in jsbin](http://jsbin.com/fiwemir/2/edit?js,console)

## 单例内置对象

### global

在全局作用域中定义的变量和函数都会成为`global`对象的属性。

常见的 global 对象属性和方法：

- 基本类型和引用类型等
- isNaN
- Infinity
- isFinate
- parseInt
- parseFloat
- encodeURI
- encodeURIComponent
- decodeURI
- decodeURIComponent
- eval

也可以通过`console.log(window)`来查看

### Math

除 global 之外，`Math`也是单例内置对象，提供了一组用于执行常见数学运算的方法。例如，可以使用 Math.max()方法来计算一组数值中的最大值，使用 Math.round()方法来对数值进行四舍五入等。

- Math.max(val1, val2, ...)：计算一组数值的最大值。
- Math.min(val1, val2, ...)：计算一组数值的最小值。
- Math.round(val)：对数值进行四舍五入。
- Math.ceil(val)：向上取整。
- Math.floor(val)：向下取整。
- Math.random()：生成一个 0 到 1 之间的随机数。

例如，下面的代码计算了一组数值的最大值、最小值、平均值：

```js
var values = [3, 5, 8, 10, 12]

// 计算最大值
var max = Math.max.apply(null, values)
console.log(max) // 12

// 计算最小值
var min = Math.min.apply(null, values)
console.log(min) // 3

// 计算平均值
var sum = 0
for (var i = 0; i < values.length; i++) {
  sum += values[i]
}
var avg = sum / values.length
console.log(avg) // 7.4
```

上面的代码中，首先使用 Math.max.apply(null, values)计算了一组数值的最大值，其中 apply 方法用于指定 Math.max 方法的作用对象为 null，并将 values 数组作为参数传入该方法。接着，使用类似的方法计算了一组数值的最小值。最后，通过遍历数组计算所有数值的和，然后除以数值的个数，得平均值。

## Date

JavaScript 的 Date 对象用于处理日期和时间。它可以获取当前日期和时间，也可以处理其他日期和时间。

要在 JavaScript 中使用 Date 对象，需要使用 Date 构造函数创建一个日期对象。语法如下：

```js
var date = new Date(
  [year],
  [month],
  [day],
  [hours],
  [minutes],
  [seconds],
  [milliseconds]
)
```

其中，参数 year、month、day、hours、minutes、seconds、milliseconds 表示年份、月份、日、小时、分钟、秒、毫秒，可以省略。如果省略，则表示使用当前日期和时间。

例如，下面的代码创建了一个日期对象，表示当前日期和时间：

```js
var date = new Date()
```

JavaScript 的 Date 对象提供了很多方法，用于处理日期和时间。例如，可以使用 getFullYear 方法来获取年份，使用 getMonth 方法来获取月份，使用 getDate 方法来获取日期等。

例如，下面的代码获取了当前日期对象的年份、月份、日期：

```js
var date = new Date()
var year = date.getFullYear()
var month = date.getMonth()
var day = date.getDate()
```

此外，JavaScript 的 Date 对象还提供了一些静态方法，可以用于创建特定日期和时间的日期对象。例如，可以使用 Date.parse 方法来解析日期字符串

Date 对象提供了许多方法来处理日期和时间信息，下面列出一些常用的方法：

- getFullYear()：获取当前日期所在年份。
- getMonth()：获取当前日期所在月份（0-11）。
- getDate()：获取当前日期所在月份的日期（1-31）。
- getDay()：获取当前日期所在周的星期（0-6，0 表示星期天，1 表示星期一，以此类推）。
- getHours()：获取当前时间的小时数（0-23）。
- getMinutes()：获取当前时间

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

## Regexp

正则表达式（Regular Expression，简称 regexp 或 regex）是用来描述、匹配文本模式的一种工具。在 JavaScript 中，可以使用正则表达式来搜索、替换、提取字符串中的指定文本，从而实现对文本的高级操作。

要在 JavaScript 中使用正则表达式，需要使用 RegExp 构造函数来创建一个正则表达式对象。语法如下：

```js
var regexp = new RegExp(pattern[, flags]);
```

其中，pattern 是正则表达式的模式字符串，flags 是可选的标志字符串，用来指定正则表达式的匹配方式。

例如，下面的代码创建了一个正则表达式对象，该对象可以匹配字符串"hello"：

```js
var regexp = new RegExp('hello')
```

JavaScript 的正则表达式有两种匹配方式：全局匹配和非全局匹配。

在全局匹配模式下，正则表达式会尝试匹配整个字符串，并返回所有匹配结果。要在正则表达式中使用全局匹配，需要在模式字符串中加入一个"g"标志，如下所示：

```js
var regexp = new RegExp('hello', 'g')
```

在非全局匹配模式下，正则表达式会尝试匹配字符串的一部分
