基于react、tailwindcss开发自己的chrome插件

Chrome插件开发 - Popup extension


浅路由是在同一个路由中跳转，不会调用数据获取函数，比如：`getServerSideProps`、`getStaticProps`等。

启用浅路由的方式，在路由跳转中设置`shallow`为`true`

```jsx
import Router from 'next/router'
import Head from 'next/head'

function HomePage(props) {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <span
        onClick={() => Router.push('/?counter=1', undefined, {shallow: true})}
      >
        Reload
      </span>
      <br />
      <div>Next stars: {props.stars}</div>
      <img src="/logo.png" alt="Logo" />
    </>
  )
}

export async function getServerSideProps(context) {
  const res = await fetch('https://api.github.com/repos/vercel/next.js')
  const json = await res.json()
  return {
    props: {stars: json.stargazers_count}
  }
}

export default HomePage
```

上面的代码仅接收路由的参数更新，且不会被替换。


浅路由是在同一个路由中跳转，不会调用数据获取函数。

Next.js - Shallow Routing


## 3 种数组去重方法

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

## Set

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
console.log([...new Set(arr)])
```

## filter

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
arr.filter((item,index)=>arr.indexOf(item)===index)
```

## reduce

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
arr.reduce((unique,item)=>unique.includes(item)?unique:[...unique,item],[])
```


数组去重


**nohup**用于忽略 SIGHUP ("signal hang up" 译：挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行。

nohup 命令在默认情况下（非重定向时），会输出一个名叫 nohup.out 的文件到当前目录下，如果当前目录的 nohup.out 文件不可写，输出重定向到 $HOME/nohup.out 文件中。

## 使用方法

```bash
nohup <command>
```

停止运行

```bash
#使用如下命令找到进程pid，然后使用kill杀掉进程
ps -aux | grep <command>
```

## 参数

- Command：要执行的命令。
- Arg：一些参数，可以指定输出文件。
- &：让命令在后台执行，终端退出后命令仍旧执行。

nohup 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用


用于忽略 SIGHUP (挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行

Linux命令nohup


Next.js 允许使用 css-in-js 语法，并且支持 css-modules。比如`styled-jsx`、`css-modules`、`styled-components`等。

创建`container.module.css`

```css
.container {
  max-width: 960px;
  margin: 0 auto;
  padding: 0 20px;
  border: 1px solid #ddd;
}
```

在`component`目录下创建`container.jsx`并引入`container.module.css`

```jsx
import styles from './container.module.css'

function Container({children}) {
  return <div className={styles.container}>{children}</div>
}

export default Container
```

在`first.js`中引入`container.jsx`

```jsx
import Link from 'next/link'
import Head from 'next/head'
import Container from '../../components/container'

export default function FirstPost() {
  return (
    <>
      <Container>
        <Head>
          <title>My First Post</title>
        </Head>
        <h1>My First Post</h1>
        <h2>
          <Link href="/">
            <a>Home</a>
          </Link>
        </h2>
      </Container>
    </>
  )
}
```

启动服务

```bash
npm run dev
```

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


Next.js允许使用css-in-js语法，并且支持css-modules。

Next.js - CSS Support


## 字符串文本

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

```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 - 字符类型


控制流是指程序中的执行顺序。在计算机程序中，控制流可以由条件语句、循环语句和跳转语句等控制语句来实现。这些语句可以改变程序的执行流程，使得程序可以按照不同的路径执行不同的代码块。

条件语句是控制流的基础，它根据指定的条件来执行或跳过特定的代码块。在 Go 语言中，条件语句包括 if 语句和 switch 语句。if 语句根据指定的条件来选择性地执行一段代码，例如：

```go
func main() {
    x := 10
    if x > 5 {
        fmt.Println("x is greater than 5")
    } else {
        fmt.Println("x is less than or equal to 5")
    }
}
```

switch 语句根据不同的条件选择性地执行不同的代码块。例如：

```go
func main() {
    x := 2
    switch x {
    case 1:
        fmt.Println("x is 1")
    case 2:
        fmt.Println("x is 2")
    default:
        fmt.Println("x is not 1 or 2")
    }
}
```

循环语句是另一种控制流的基础，它可以重复执行一段代码块直到满足指定的条件为止。在 Go 语言中，循环语句包括 for 语句和 range 语句。for 语句可以用于循环执行一段代码块，例如：

```go
func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}
```

range 语句可以用于遍历数组、切片、映射和通道等集合类型。例如：

```go
func main() {
    nums := []int{1, 2, 3, 4, 5}
    for i, num := range nums {
        fmt.Printf("Index: %d, Value: %d\n", i, num)
    }
}
```

跳转语句可以用于改变程序的执行流程。在 Go 语言中，跳转语句包括 break、continue 和 goto 语句。break 语句可以用于从循环中跳出，continue 语句可以用于跳过循环中的某个迭代，而 goto 语句可以用于跳转到程序的指定位置。例如：

```go
func main() {
    for i := 0; i < 5; i++ {
        if i == 3 {
            break
        }
        fmt.Println(i)
    }
}
```
