Working with Assets and Navigation in Flutter


Swift 支持常见的数学运算，包括算术运算、比较运算和逻辑运算。

## 算术运算：

- 加法（+）：将两个数值相加，例如：3 + 2 = 5。
- 减法（-）：将两个数值相减，例如：3 - 2 = 1。
- 乘法（_）：将两个数值相乘，例如：3 _ 2 = 6。
- 除法（/）：将一个数值除以另一个数值，例如：3 / 2 = 1.5。
- 取余（%）：返回除法操作的余数，例如：3 % 2 = 1。

## 比较运算：

- 相等（==）：检查两个数值是否相等，例如：3 == 2，结果为 false。
- 不相等（!=）：检查两个数值是否不相等，例如：3 != 2，结果为 true。
- 大于（\>）：检查第一个数值是否大于第二个数值，例如：3 \> 2，结果为 true。
- 小于（\<）：检查第一个数值是否小于第二个数值，例如：3 \< 2，结果为 false。
- 大于等于（\>=）：检查第一个数值是否大于或等于第二个数值，例如：3 \>= 2，结果为 true。
- 小于等于（\<=）：检查第一个数值是否小于或等于第二个数值，例如：3 \<= 2，结果为 false。

## 逻辑运算：

- 逻辑非（!）：返回相反的布尔值，例如：!true，结果为 false。
- 逻辑与（&&）：如果两个操作数都是 true，则返回 true；否则返回 false。例如：true && false，结果为 false。
- 逻辑或（||）：如果两个操作数中有至少一个是 true，则返回 true；否则返回 false。例如：true || false，结果为 true。
  在 Swift 中，这些运算符可以组合使用，以便进行复杂的数学、比较和逻辑运算。例如，您可以将加法和比较运算符组合在一起，以检查两个数值的总和是否大于或等于一个给定的值。

以下是一个简单的示例，演示了如何使用 Swift 的运算符：

```swift
let a = 3
let b = 2

// 算术运算
let sum = a + b
let difference = a - b
let product = a * b
let quotient = a / b
let remainder = a % b

// 比较运算
let isEqual = a == b
let isNotEqual = a != b
let isGreater = a > b
let isLess = a < b
let isGreaterOrEqual = a >= b
let isLessOrEqual = a <= b

// 逻辑运算
let logicalNot = !isEqual
let logicalAnd = isEqual && isGreater
let logicalOr = isLess || isNotEqual
```

这个示例定义了两个常量 a 和 b，并使用算术运算、比较运算和逻辑运算符计算它们之间的关系。您可以将此示例复制并粘贴到您的 Xcode 项目中，以查看运算结果。

Swift 还支持其他类型的运算，例如位运算和区间运算。如果您想了解有关这些运算符的更多信息，请参阅 Swift 官方文档。


Swift 支持常见的数学运算，包括算术运算、比较运算和逻辑运算。

Swift - 基本运算


通过插件修改网页

当点击扩展选项的时候，网页颜色跟着改变

<video
  src="https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/modify-page_rux0n9.webm"
  autoPlay
/>

修改`manifest.json`

```json diff
{
  "permissions": [
    "alarms",
    "notifications",
    "storage",
    + "activeTab",
    + "scripting"
  ]
}
```

新增权限解释

- `activeTab`允许修改和检索活动标签
- `scripting`允许向浏览器注入脚本

修改`src/App.jsx`，向弹窗页面增加按钮

```jsx
import React from 'react'

export default function Colorize() {
  const colorize = async () => {
    const [tab] = await chrome.tabs.query({active: true, currentWindow: true})
    chrome.scripting.executeScript({
      target: {tabId: tab.id},
      function: changeColor
    })
  }

  const changeColor = () => {
    chrome.storage.sync.get('color', ({color}) => {
      document.body.style.backgroundColor = color
    })
  }

  return <button onClick={colorize}>Colorize 💖</button>
}
```

## Source Code

[【Source Code】](https://github.com/rebelchris/popup-extension/tree/page-modifications)


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

Chrome插件开发 - Popup page modifications


ES6（ECMAScript 2015）引入了解构赋值（Destructuring Assignment）语法，它是一种方便地从数组或对象中提取值并赋给变量的方式。解构赋值可以简化代码，使得操作数据更加灵活和可读。

解构赋值可以用于数组和对象，下面分别解释它们的用法：

## 数组解构赋值：

数组解构赋值允许我们通过模式匹配的方式从数组中提取值并赋给变量。

示例：

```javascript
const numbers = [1, 2, 3, 4, 5]

// 通过解构赋值提取数组中的值
const [a, b, c, d, e] = numbers

console.log(a) // 输出: 1
console.log(b) // 输出: 2
console.log(c) // 输出: 3
console.log(d) // 输出: 4
console.log(e) // 输出: 5
```

在上述示例中，我们使用解构赋值从数组 `numbers` 中提取了每个元素的值，并将它们分别赋给变量 `a`、`b`、`c`、`d` 和 `e`。

解构赋值还可以使用默认值，以防提取的值为 `undefined`：

示例：

```javascript
const numbers = [1, 2]

const [a, b, c = 3] = numbers

console.log(a) // 输出: 1
console.log(b) // 输出: 2
console.log(c) // 输出: 3
```

在上述示例中，数组 `numbers` 只有两个元素，但我们通过解构赋值提取了三个变量。由于第三个元素不存在，变量 `c` 使用了默认值 `3`。

## 对象解构赋值：

对象解构赋值允许我们通过模式匹配的方式从对象中提取值并赋给变量。

示例：

```javascript
const person = {
  name: 'John',
  age: 30,
  address: '123 Main St'
}

// 通过解构赋值提取对象中的值
const {name, age, address} = person

console.log(name) // 输出: 'John'
console.log(age) // 输出: 30
console.log(address) // 输出: '123 Main St'
```

在上述示例中，我们使用解构赋值从对象 `person` 中提取了每个属性的值，并将它们赋给了同名的变量。

对象解构赋值也可以使用默认值：

示例：

```javascript
const person = {
  name: 'John',
  age: 30
}

const {name, age, address = 'Unknown'} = person

console.log(name) // 输出: 'John'
console.log(age) // 输出: 30
console.log(address) // 输出: 'Unknown'
```

在上述示例中，对象 `person` 中没有 `address` 属性，但我们通过解构赋值为变量 `address` 设置了默认值 `'Unknown'`。

解构赋值还可以嵌套使用，同时可以结合数组和对象的解构赋值。它还支持使用剩余运算符（Rest Operator）来获取剩余的数组元素或对象属性。

总结起来，ES6 的解构赋值语法提供了一种简洁而强大的方式来从数组和对象中提取值并赋给变量。它使得代码更加简洁可读，并且可以结合默认值、嵌套和剩余运算符等功能实现更复杂的数据操作。


ES6 - 解构赋值


Next.js 预渲染支持两种方式：

- SSG 预渲染
- SSR 预渲染

## SSG 预渲染

SSG 预渲染是指在构建时生成 HTML，可以在没有数据的情况下完成，在这种情况下，HTML 页面将准备就绪，而无需预先获取数据，然后开始渲染。

数据可以稍后或应要求提供。

优点：这种方式可以解决白屏问题、SEO 问题
缺点：所有用户看到的都是同一个页面，无法生成用户相关内容

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

export default function FirstPost(props) {
  return (
    <>
      <Container>
        <Head>
          <title>My First Post</title>
        </Head>
        <h1>My First Post</h1>
        <h2>
          <Link href="/">
            <a>Home</a>
          </Link>
          <div>Next stars: {props.stars}</div>
        </h2>
      </Container>
    </>
  )
}

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

## SSR 预渲染

后端将页面渲染，返回 HTML String 格式，传递到前端，前端进行 hydrate() ,会保留 HTML 并附上时间监听，也就是说后端渲染 HTML，前端添加监听。

前端也会渲染一次，用以确保前后端渲染结果一致

每个组件都有一个特殊的方法`getStaticProps`，可用于获取数据并作为页面的属性传递数据。

## 使用 getServerSideProps

```js
import Link from 'next/link'
import Head from 'next/head'

function HomePage(props) {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <Link href="/posts/first">
        <a>First Post</a>
      </Link>
      <br />
      <div>Next stars: {props.stars}</div>
      <img src="/logo.png" alt="TutorialsPoint 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
```

启动服务

```bash
npm run dev
```


Next.js - Pre-Rendering


浅路由是在同一个路由中跳转，不会调用数据获取函数，比如：`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


## 抽奖类型

- 圆形抽奖
- 方形抽奖
- 老虎机
- 刮刮卡

### 圆形抽奖

代码如下：

```js
// prefix补全
var CSSTransform = (function () {
  var _elementStyle = document.createElement('div').style
  var _vendor = (function () {
    var vendors = ['t', 'webkitT', 'MozT', 'msT', 'OT'],
      transform,
      i = 0,
      l = vendors.length
    for (; i < l; i++) {
      transform = vendors[i] + 'ransform'
      if (transform in _elementStyle)
        return vendors[i].substr(0, vendors[i].length - 1)
    }
    return false
  })()

  function _prefixStyle(style) {
    if (_vendor === false) return false
    if (_vendor === '') return style
    return _vendor + style.charAt(0).toUpperCase() + style.substr(1)
  }
  return _prefixStyle('transform')
})()

// 转盘旋转效果
var Lottery = function (el) {
  this.running = false
  this.el = $(el)[0]
  /*
	    旋转转盘至指定位置
	    参数：
	    giftIndex: 礼物的索引（从0开始到数组.length - 1）
	    endCallback：转盘旋转完成时的回调
	    */
  this.rotateToGift = function (giftIndex, endCallback) {
    if (typeof endCallback != 'function') return
    if (giftIndex < 0 || giftIndex > CNST_GIFTS.length - 1) return
    if (this.running) return
    this.running = true
    var degToRotate = (giftIndex + 1) * 45 + 360 * 3 - 22.5 //最少转3圈
    var rotatedDeg = 0
    var speed = 20 //deg
    var speedRatio = 1
    var _this = this

    function r() {
      _this.el.style[CSSTransform] = 'rotate(' + -rotatedDeg + 'deg)'
      rotatedDeg += speed * speedRatio
      if (rotatedDeg + 180 >= degToRotate)
        //开始减速
        speedRatio = (degToRotate - rotatedDeg) / 180
      if (rotatedDeg >= degToRotate - 0.5) {
        rotatedDeg = degToRotate
        _this.el.style[CSSTransform] = 'rotate(' + -rotatedDeg + 'deg)'
        _this.running = false
        endCallback()
      } else setTimeout(r, 1000 / 24)
    }
    r()
  }
}
```

**使用方法：**

```html
<div class="lottery">
  <div class="lottery-bg"></div>
  <button id="btnStart" class="button start" onClick="startLottery()"></button>
</div>
```

调用方法：

```js

var myLottery = new Lottery($(".lottery .lottery-bg"));//初始化转盘
myLottery.rotateToGift(giftIndex, function() {
	    //giftIndex为后端接口下发的奖品ID，function为回调函数
}
```

待续
