列表（List）是 python 的基本类型

Lists - 列表


在 Swift 中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。

Swift 提供了两种类型转换方式：

- 通过类型检查来检查实例的类型是否与特定的类型相同（或是子类或父类）：使用 is 和 as 操作符来完成类型检查。

  - is 操作符用于检查一个实例是否属于某个特定类型或其子类。返回值为布尔类型。
  - as? 操作符用于尝试将实例转换为特定类型。如果转换成功，返回一个可选类型的实例，否则返回 nil。
  - as! 操作符强制将实例转换为特定类型。如果转换失败，会抛出一个运行时错误。

- 通过向下转换来将父类实例转换为其子类实例：使用 as? 或 as! 操作符完成向下转换。
  - as? 操作符尝试将父类实例转换为子类实例。如果转换成功，返回一个可选类型的子类实例，否则返回 nil。
  - as! 操作符强制将父类实例转换为子类实例。如果转换失败，会抛出一个运行时错误。

下面是一个示例代码：

```swift
class Animal {
  func makeSound() {
    print("I am an animal")
  }
}

class Dog: Animal {
  override func makeSound() {
    print("Woof!")
  }
}

let animal = Animal()
let dog = Dog()

// Type check
if dog is Animal {
  print("dog is an Animal")
}

// Downcasting
let maybeDog = animal as? Dog
if let dog = maybeDog {
  dog.makeSound()
} else {
  print("Not a dog")
}

// Forced downcasting
let definitelyDog = animal as! Dog // Runtime error!
```

在上面的代码中，我们创建了一个 Animal 类和一个继承自 Animal 的 Dog 类。使用 is 操作符检查 dog 实例是否是 Animal 类的子类，并使用 as? 操作符尝试将 Animal 实例转换为 Dog 实例。最后，使用 as! 操作符强制将 Animal 实例转换为 Dog 实例（如果尝试转换一个非 Dog 实例，则会引发运行时错误）


在Swift中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。。

Swift - 类型转换


## First Program

创建`hellowrold.js`，打开控制台执行`node helloworld.js`

```js
console.log('hello world')

// hello world
```

## 基于`http`创建一个简单 server

一个简单`nodejs server`程序包含三个必备条件

- 引入依赖包
- 创建 server
- 获取请求和返回

引入依赖包

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

创建 server

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

http
  .createServer(function (req, res) {
    response.writeHead(200, {'Content-Type': 'text/plain'})
    response.end('Hello World\n')
  })
  .listen(8888)

console.log('Server running at http://127.0.0.1:8888/')
```

启动 server

```bash
node server.js
#Server running at http://127.0.0.1:8888/
```

## 进入 REPL(交互解释器)模式

REPEL 即交互解释器，使用单个表达式作为用户输入，并在执行后将结果返回到控制台

```bash
node
```

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

使用<kbd>tab</kbd>显示当前输入对象的扩展，比如输入`Number.`后按下<kbd>tab</kbd>

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


Node.js - First Program & REPL


`DISTINCT`用于返回数据删除重复行

## 语法

```sql
#单列
SELECT
   DISTINCT column1
FROM
   table_name;

#多列
SELECT
   DISTINCT column1, column2
FROM
   table_name;
```

`DISTINCT ON (expression)`，保留每组重复性的第一行。

```sql
SELECT
   DISTINCT ON (column1) column_alias,
   column2
FROM
   table_name
ORDER BY
   column1,
   column2;
```

> `DISTINCT ON (expression)`必需是`ORDER BY`最左边的表达式

## 示例

创建名为`distinct_demo`的新表，导入数据：

```sql
#创建新表
CREATE TABLE distinct_demo (
	id serial NOT NULL PRIMARY KEY,
	bcolor VARCHAR,
	fcolor VARCHAR
);

#插入数据
INSERT INTO distinct_demo (bcolor, fcolor)
VALUES
	('red', 'red'),
	('red', 'red'),
	('red', NULL),
	(NULL, 'red'),
	('red', 'green'),
	('red', 'blue'),
	('green', 'red'),
	('green', 'blue'),
	('green', 'green'),
	('blue', 'red'),
	('blue', 'green'),
	('blue', 'blue');

#查询数据
SELECT
	id,
	bcolor,
	fcolor
FROM
	distinct_demo ;
```

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

#### 单列示例

```sql
SELECT
	DISTINCT bcolor
FROM
	distinct_demo
ORDER BY
	bcolor;
```

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

#### 多列示例

```sql
SELECT
	DISTINCT bcolor,
	fcolor
FROM
	distinct_demo
ORDER BY
	bcolor,
	fcolor;
```

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

多列示例中，同时指定了`bgcolor`和`fcolor`，Postgresql 结合列的值计算并返回每行的唯一性。

#### `DISTINCT ON (expression)`示例

```sql
SELECT
	DISTINCT ON (bcolor) bcolor,
	fcolor
FROM
	distinct_demo
ORDER BY
	bcolor,
	fcolor;
```

以上语句按照`bgcolor`和`fcolor`进行排序，对于每组重复项，保留并返回第一行。

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


Postgresql - Select Distinct


使用`WHERE`过滤`SELECT`返回行。

## 语法

```sql
SELECT select_list
FROM table_name
WHERE condition
ORDER BY sort_expression
```

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

**如果在语句中使用了列别名，就不能使用`WHERE`**

| Operator   | Description |
| ---------- | ----------- |
| =          | 等于        |
| `>`        | 大于        |
| `<`        | 小于        |
| `>=`       | 大于等于    |
| `<=`       | 小于等于    |
| `<>` or != | 不等于      |
| AND        | 逻辑与      |
| OR         | 逻辑或      |
| IN         | 包含        |
| BETWEEN    | 区间        |
| LIKE       | 相似匹配    |
| IS NULL    | 非空        |
| NOT        | 不是        |

## 示例

从示例数据库中查询

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

#### =

查询`first_name`等于`Jamie`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie';
```

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

#### AND

查询`first_name`等于`Jamie`和`last_name`等于`Rice`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie' AND
        last_name = 'Rice';
```

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

#### OR

查询`last_name`等于`Rodriguez`或`first_name`等于`Adam`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	last_name = 'Rodriguez' OR
	first_name = 'Adam';
```

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

#### IN

查询包含`Ann、Anne、Annie`任何一个

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name IN ('Ann','Anne','Annie');
```

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

#### LIKE

查询以`Ann`开头的`last_name`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Ann%'
```

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

#### BETWEEN

查询`first_name`的长度大于等于 3 小于等于 5

```sql
SELECT
	first_name,
	LENGTH(first_name) name_length
FROM
	customer
WHERE
	first_name LIKE 'A%' AND
	LENGTH(first_name) BETWEEN 3 AND 5
ORDER BY
	name_length;
```

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

#### `<>`

查询`first_name`以`Bra`开头，而且`last_name`不等于`Motley`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Bra%' AND
	last_name <> 'Motley';
```

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

`<>`和`!=`是相同的作用。


Postgresql - Where


在Go语言中，接口（Interface）是一种类型，它定义了一组方法的契约。接口定义了方法的集合，而不关心方法的具体实现。接口提供了一种抽象的方式来描述对象的行为。

Go中的接口由一组方法签名组成，方法签名定义了方法的名称、参数列表和返回值类型。一个类型只要实现了接口中定义的所有方法，就被认为是实现了该接口。通过这种方式，接口实现了多态的特性，即不同类型的对象可以以相同的接口类型进行处理。

## 接口定义

```go
type 接口类型名 interface{
    方法名1(参数列表1) 返回值列表1
    方法名2(参数列表2) 返回值列表2
    …
}
```

## 接口实现

```go
type 类型名 struct{
    //字段
}
//实现接口方法
func (变量名 类型名) 方法名1(参数列表1) 返回值列表1{
    //方法体
}
func (变量名 类型名) 方法名2(参数列表2) 返回值列表2{
    //方法体
}
```

接口的实现是隐式的，不需要显式声明。只要一个类型实现了接口中定义的所有方法，即可视为实现了该接口。例如：

```go
type Animal interface {
    Speak() string
}

type Dog struct {}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var animal Animal
    animal = Dog{}
    fmt.Println(animal.Speak()) // 输出: "Woof!"
}
```

在上面的例子中，我们定义了一个 Animal 接口，只有一个 Speak 方法。然后，我们创建了一个 Dog 结构体，并为 Dog 类型实现了 Speak 方法。在 main 函数中，我们将 Dog 类型赋值给 Animal 类型的变量 animal，并调用了 Speak 方法。
接口的特点和用途包括：

- 多态性：接口允许在不同的类型之间实现多态。通过将对象视为接口类型，可以处理不同类型的对象，而无需关心其具体的类型。
- 松耦合：接口可以实现组件之间的松耦合，组件只需要关注接口定义的方法，而不需要关心具体的实现。
- 可插拔性：接口可以作为插件或模块的契约，允许将不同的实现替换为其他实现，而不会影响使用该接口的其他代码。


Go Inteface是一种类型，一种抽象的类型。

Go - 接口


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

## 原始包装类型

### 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')
```

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