在 Next.js 中，可以创建动态路由

Next.js - Dynamic API Routes


`React`中应用元素样式有以下几种方式：

引入全局样式

![KUPCw2](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/KUPCw2.jpg)
![p96k3B](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/p96k3B.jpg)

行内样式

```jsx
function App() {
  return (
    <header className="App-header">
      <p style={{margin: '1px', padding: '5px'}}>
        <code>src/App.js</code>
      </p>
      <a
        style={{color: 'red', backgroundColor: 'green'}}
        className="App-link"
        href="https://reactjs.org"
        target="_blank"
      >
        Learn React
      </a>
    </header>
  )
}
```

为各个组件创建单独的样式，并且在组件中使用

```jsx
import React from 'react'
import './App.css'

function App() {
  return (
    <header className="App-header">
      <p style={{margin: '1px', padding: '5px'}}>
        <code>src/App.js</code>
      </p>
      <a
        style={{color: 'red', backgroundColor: 'green'}}
        className="App-link"
        href="https://reactjs.org"
        target="_blank"
      >
        Learn React
      </a>
    </header>
  )
}

export default App
```

将 `style` 属性附加到 `JavaScript` 样式对象

```jsx
import React from 'react'

var stylingObject = {
  div: {
    color: 'red',
    border: '1px solid red'
  },
  input: {
    margin: '2px',
    padding: '5px'
  }
}

function App() {
  return (
    <div style={stylingObject.div}>
      <input style={stylingObject.input} type="text" />
    </div>
  )
}

export default App
```


React是一个JavaScript库，致力于使UI开发变得简单

React Elements Styles


所有有效的 URL 都遵循某些规则。因此，如果了解了这些模规则，就可以确定 URL 是否有效。

- 如何使用`URL`构造器校验 URLs
- 如何使用 npm 包校验 URLs
- 如何使用正则校验 URLs

## 如何使用`URL`构造器校验 URLs

当向`URL`函数中传入字符串时，如果是有效的 url 会返回 url 对象，否则会抛出异常

```js
const fccUrl = new URL('https://www.freecodecamp.org/')
console.log(fccUrl)
```

控制台将输出以下内容：

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

当传入值是无效的 url 时:

freecodecamp 为无效的 url 链接，将抛出异常

```js
const fccUrl = new URL('freecodecamp')
console.log(fccUrl)
```

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

## 如何创建校验 url 有效性函数

```js
function isValidUrl(str) {
  try {
    new URL(str)
    return true
  } catch (e) {
    return false
  }
}

console.log(isValidUrl('https://www.freecodecamp.org/')) // true
console.log(isValidUrl('mailto://mail@freecodecamp.org')) // true
console.log(isValidUrl('freecodecamp')) // false
```

当传入值是有效 url，则返回 true，否则返回 false。

## 如何校验`http`url

有时需要区分 http 协议和其他协议，比如`mailto://mail@freecodecamp.org`

对`isValidUrl`函数做点改动，对返回的协议检查

```js
function isValidHttpUrl(str) {
  try {
    const newUrl = new URL(str)
    return newUrl.protocol === 'http:' || newUrl.protocol === 'https:'
  } catch (e) {
    return false
  }
}

console.log(isValidHttpUrl('https://www.freecodecamp.org/')) // true
console.log(isValidHttpUrl('mailto://mail@freecodecamp.org')) // false
console.log(isValidHttpUrl('freecodecamp')) // false
```

## 如何使用 npm 包校验

`is-url`、`is-url-http`

```js
import isUrl from 'is-url'
import isUrlHttp from 'is-url-http'

const firstCheck = isUrl('https://www.freecodecamp.org/')
const secondCheck = isUrl('mailto://mail@freecodecamp.org')
const thirdCheck = isUrl('freeCodeCamp')

console.log(firstCheck) // true
console.log(secondCheck) // true
console.log(thirdCheck) // false

const firstCheck = isUrlHttp('https://www.freecodecamp.org/')
const secondCheck = isUrlHttp('mailto://freecodecamp@mail.org')
const thirdCheck = isUrlHttp('freeCodeCamp')

console.log(firstCheck) // true
console.log(secondCheck) // false
console.log(thirdCheck) // false
```

## 如何使用正则校验

所有有效链接遵循以下几种规则

- 协议
- 域名或 ip
- 端口或路径

你可以在[【The structure of URLS】](https://www.freecodecamp.org/news/what-happens-when-you-hit-url-in-your-browser/)学习更多关于`URL 规则`

知道模式 URL 是由什么组成的，您可以使用正则表达式检查字符串中是否存在这样的模式。

如果模式存在，则字符串通过正则表达式测试。否则就会失败。

此外，使用正则表达式，您可以检查所有有效的 URL，或者只检查有效的 HTTP URL。

```js
function isValidUrl(str) {
  const pattern = new RegExp(
    '^([a-zA-Z]+:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR IP (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$', // fragment locator
    'i'
  )
  return pattern.test(str)
}

console.log(isValidUrl('https://www.freecodecamp.org/')) // true
console.log(isValidUrl('mailto://freecodecamp.org')) // true
console.log(isValidUrl('freeCodeCamp')) // false
```

校验协议并未严格限制`http`或`https`，所有`mailto`开头的协议会返回`true`，稍作改动仅校验`http`

```js
function isValidHttpUrl(str) {
  const pattern = new RegExp(
    '^(https?:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$', // fragment locator
    'i'
  )
  return pattern.test(str)
}

console.log(isValidHttpUrl('https://www.freecodecamp.org/')) // true
console.log(isValidHttpUrl('mailto://freecodecamp.org')) // false
console.log(isValidHttpUrl('freeCodeCamp')) // false
```


如何校验URLs？


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

JavaScript 是一种基于原型的面向对象编程语言。每一个 JavaScript 对象都有一个原型，它指向另一个对象。当试图访问一个对象的属性或方法时，如果对象本身不存在这个属性或方法，JavaScript 引擎会在对象的原型中寻找。

原型链是指一系列从一个对象到其他对象的链接。当我们试图访问一个对象的属性或方法时，JavaScript 引擎会沿着这个原型链一直向上搜索，直到找到该属性或方法，或者到达链的末端。

举个例子：如果我们有一个 "Person" 对象，它可以有一个原型 "Human"，而 "Human" 又有一个原型 "Animal"。当我们试图访问 "Person" 对象的某个属性或方法时，如果 "Person" 不存在该属性或方法，JavaScript 引擎就会在 "Human" 中寻找，如果 "Human" 中也不存在，就会在 "Animal" 中寻找。

简单来说，JavaScript 原型和原型链是为了解决对象继承问题，使得我们可以在多个对象之间共享属性和方法。


原型和原型链


## 创建结构体

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

# 使用结构体
var person = Person(name: "John Appleseed", age: 42)
print(person.name) // Prints "John Appleseed"

# 更改结构体属性
person.age = 99
```

## 计算属性

`Swift`可以添加一个属性用来计算属性的值。

```swift
struct Person {
    var name: String
    var age: Int

    var ageInDogYears: Int {
        return age * 7
    }
}

let person = Person(name: "John Appleseed", age: 42)
person.ageInDogYears // Prints "294"
```

## 属性观察器

属性观察期允许在更改任何属性前后调用代码。

```swift
struct Progress {
    var task: String
    var amount: Int {
        didSet {
            print("\(task) is now \(amount)% complete")
        }
    }
}

Progress(task: "Loading data", amount: 0)

progress.amount = 30
progress.amount = 80
progress.amount = 100
```

如上代码在每次运行时都会打印出一条消息，每次设置新的值时都会打印出一条消息。

## 方法

结构体和类的方法和普通的函数完全一样。

```swift
struct Person {
    var name: String
    var age: Int

    func birthday() {
        return age + 1
    }
}

let person = Person(name: "John Appleseed", age: 42)
person.birthday() // Prints "43"
```

## 变异函数

如果结构体具有可变属性，但是结构体的实例是作为常量创建的，那么该属性不能更改。如果需要改变，应该使用`mutating`关键字。

```swift
struct Person {
    var name: String
    var age: Int

    mutating func birthday() {
        age += 1
    }
}
var person = Person(name: "John Appleseed", age: 42)
person.birthday() // Prints "43"
```

## 字符串的方法和属性

```swift
let str = "Hello, world"

str.count // Prints "12"
str.hasPrefix("Hello") // Prints "true"
str.uppercased() // Prints "HELLO, WORLD"
str.sorted() // Prints "H, E, L, L, O, , , W, , , o, r, l, d"
str.lowercased() // Prints "hello, world"
```

## 数组的方法和属性

```swift
var toys = ["Woody"]

toys.count // Prints "1"
toys.append("Buzz")
toys.firstIndex(of: "Buzz") // Prints "2"
toys.sorted() // Prints "[Buzz, Woody]"
toys.remove(at: 0)
```

## initializers

`initializers`是一种特殊的方法，它提供了不同的方法创建结构。默认情况所有结构都有一个`init`方法，它会自动调用所有的属性的`initializers`。

```swift
struct Person {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

var person = Person(name: "John Appleseed", age: 42)
```

## 关联当前实例

在结构方法里，使用`self`可以获取或给对应的属性赋值。类似于 js 的 this

```swift
struct Person {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    func birthday() {
        self.age += 1
    }
}
```

## 惰性属性

类似于 js 的`lazyload`，仅在需要的时候创建或引入。

```swift
struct FamilyTree{
  var name:String
  lazy var familyTree = FamilyTree()

  init(name: String){
    self.name = name
  }
}

var ed = Person(name:"Ed")

ed.familyTree
```

## 静态属性或方法

static 变量的声明用于在结构的所有实例间共享

```swift
struct Student {
    static var classSize = 0
    var name: String

    init(name: String) {
        self.name = name
        Student.classSize += 1
    }
}

Student.classSize
```

## 访问控制

- `private` 私有属性和方法，只有在结构体内才能访问
- `public` 公共属性和方法，所有代码都可使用公共属性和方法

```swift
struct Person {
    private var id: String
    public var num: Int

    init(id: String) {
        self.id = id
    }

    func identify() -> String {
        return "My social security number is \(id)"
    }
}
```

## 结构体总结

- 您可以使用结构创建自己的类型，这些结构可以有自己的属性和方法。
- 您可以使用存储的属性或使用计算的属性来动态计算值。
- 如果要更改方法内的属性，必须将其标记为`mutating`.
- 初始化器是创建结构的特殊方法。默认情况下，您会获得一个成员初始化器，但如果您创建自己的初始化器，则必须为所有属性赋值。
- 使用`self`常量来引用方法内结构的当前实例。
- `lazy`关键字告诉 `Swift` 仅在第一次使用时创建属性。
- `static`您可以使用关键字在结构的所有实例之间共享属性和方法。
- 访问控制允许您限制哪些代码可以使用属性和方法。


Swift 结构体是构建代码所用的一种通用且灵活的构造体。

Structs - 结构体


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift 中的嵌套类型具有以下特性：

- 嵌套类型可以在外部类型中使用，可以像外部类型的属性或方法一样使用嵌套类型。
- 嵌套类型可以访问外部类型的所有成员，包括私有成员。
- 嵌套类型可以继承自外部类型，也可以作为外部类型的类型成员。

使用嵌套类型可以使代码更加有组织性，也可以减少全局作用域中的名称冲突。

以下是嵌套类型示例：

```swift
struct Outer {
    var outerProperty: Int

    struct Inner {
        var innerProperty: String
    }

    func outerMethod() {
        let outerInner = Inner(innerProperty: "Inner property")
        print("outerMethod called with inner property: \(outerInner.innerProperty)")
    }
}

let outer = Outer(outerProperty: 10)
let outerInner = Outer.Inner(innerProperty: "Inner property")
outer.outerMethod()  // 输出 "outerMethod called with inner property: Inner property"
```

在上面的示例中，Outer 的内部有一个嵌套类型 Inner。Inner 中有一个成员 innerProperty。outerMethod 可以访问 Inner，并使用它创建一个实例，然后访问其成员。在外部类型中，我们可以像使用普通类型一样使用 Inner。

另外，嵌套类型还可以被用于支持泛型类型的实现。当你定义一个泛型类型时，你可以定义嵌套类型作为泛型类型的一部分，这有助于在更加抽象化的层次上组织和定义代码，从而使泛型类型更加通用化和模块化。

以下是一个嵌套类型用于支持泛型的示例：

```swift
struct Container<T> {
    var value: T

    struct Nested {
        var nestedValue: T
    }

    var nested: Nested {
        return Nested(nestedValue: value)
    }
}

let container = Container(value: 42)
let nested = container.nested // 生成一个 nestedValue 为 42 的 Container.Nested 实例
```

在这个示例中，嵌套类型 Nested 中的成员 nestedValue 的类型与容器的泛型类型参数 T 一样。实例化容器时，使用 42 初始化元素 value，然后访问其嵌套类型 Nested。内部类型 Nested 通过嵌套容器类型的泛型类型参数 T 来支持类型实例化。

总之，在 Swift 中，嵌套类型有助于组织和定义代码，减少名称冲突，提高代码可读性和可管理性，并支持泛型类型实现。


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift - 嵌套类型


## typeof

使用`typeof`可以判断一个变量的类型，返回值为`string`，可以使用`instanceof`来判断一个对象是否是某个类的实例。

我们使用运算符 typeof 检查 getMonth 方法是否是一个函数，看看它是否返回`function`

```js
const date = new Date(2021, 1, 1)
console.log(typeof date.getMonth === 'function')
```

如果返回`true`，说明 getMonth 是一个函数，`date`可能是`Date`实例，如果返回`false`，说明 getMonth 是一个字符串。

## instanceof

instanceof 可以用来判断一个对象是否是某个类的实例，返回值为`boolean`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

如果返回`true`，说明 date 是一个`Date`实例，如果返回`false`，说明 date 不是一个`Date`实例。

## Object.prototype.toString

Object.prototype.toString 方法可以返回一个对象的字符串表示，返回值为`string`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

## isValid Date

判断一个对象是否是一个有效的日期对象，返回值为`boolean`。

```js
Object.prototype.toString
```
