一些有用的Html&&css&&javascript Tips


在 Go 语言中，数组和切片是常见的数据类型。它们都可以用来存储一组有序的数据，但它们在底层实现和使用方式上有所不同。

## 数组 (Array)

数组是一种固定大小的数据结构，它由一系列具有相同类型的元素组成，这些元素在内存中是连续存储的。数组的大小在定义时就确定，不能修改。在 Go 语言中，数组的定义方式如下：

```go
var a [5]int // 定义一个长度为 5 的整型数组
```

在数组中访问和修改元素可以使用索引操作符 []，索引从 0 开始。例如，要访问数组中的第一个元素，可以使用 a[0]。

下面是一个简单的示例，演示如何使用数组：

```go
package main

import "fmt"

func main() {
    var a [5]int
    a[0] = 1
    a[1] = 2
    a[2] = 3
    a[3] = 4
    a[4] = 5

    fmt.Println("Array:", a) // 输出整个数组

    fmt.Println("Length:", len(a)) // 输出数组的长度

    fmt.Println("First element:", a[0]) // 输出数组的第一个元素

    fmt.Println("Last element:", a[len(a)-1]) // 输出数组的最后一个元素
}
```

输出结果如下：

```go
Array: [1 2 3 4 5]
Length: 5
First element: 1
Last element: 5
```

需要注意的是，当将数组传递给函数时，将传递整个数组的副本而不是指向原始数组的指针。这意味着，在函数中对数组的修改不会影响原始数组的值。

## 切片 (Slices)

切片是一种动态大小的数据结构，它是基于数组实现的。切片可以看作是一个指向数组的指针，它包含一个指向数组的指针、长度和容量。切片的长度表示它当前包含的元素数量，而容量表示它可以包含的元素数量，容量可以在运行时动态扩展。在 Go 语言中，可以使用以下方式来创建切片：

```go
a := []int{1, 2, 3, 4, 5} // 使用字面量创建切片

b := make([]int, 5) // 使用 make 函数创建长度为 5 的整型切片
```

可以使用索引操作符 [] 访问和修改切片中的元素。可以使用 append 函数向切片中添加新元素。以下是一个简单的示例：

```go
package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4, 5}

    fmt.Println("Slice:", a) // 输出整个切片

    fmt.Println("Length:", len(a)) // 输出切片的长度

    fmt.Println("Capacity:", cap(a)) // 输出切片的容量

    fmt.Println("First element:", a[0]) // 输出切片的第一个元素

    fmt.Println("Last element:", a[len(a)-1]) // 输出切片的最后一个元素

    a = append(a, 6) // 向切片中添加一个元素

    fmt.Println("Slice after append:", a) // 输出添加元素后的切片
}

```

输出结果如下：

```shell
Slice: [1 2 3 4 5]
Length: 5
Capacity: 5
First element: 1
Last element: 5
Slice after append: [1 2 3 4 5 6]
```

需要注意的是，当将切片传递给函数时，将传递一个指向底层数组的指针。这意味着，在函数中对切片的修改将影响原始切片的值。

另外，切片还有一个重要的特性，就是可以使用切片表达式从一个已有的切片中获取一个新的切片。切片表达式的语法如下：

a[low:high]

其中，low 和 high 分别表示新切片的第一个和最后一个元素的索引（不包含最后一个元素）。以下是一个示例：

```go
package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4, 5}

    b := a[1:3] // 获取 a[1] 到 a[2]（不包含 a[3]）的切片

    fmt.Println("Slice:", b) // 输出新的切片
}
```

输出结果如下：

```shell
Slice: [2 3]
```

需要注意的是，切片表达式返回的是一个新的切片，它共享原始切片的底层数组。这意味着，在新切片和原始切片中修改元素将影响到彼此。因此，在使用切片表达式时需要格外小心。


Go - 数组、切片


## 抽奖类型

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

### 圆形抽奖

代码如下：

```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为回调函数
}
```

待续


移动端抽奖


react 使用`.map`遍历并显示列表组件。

```jsx
function SoccerPlayers() {
  const players = ['Messi', 'Ronaldo', 'Laspada']

  return (
    <div>
      {players.map((playerName) => (
        <SoccerPlayer key={playerName} name={playerName} />
      ))}
    </div>
  )
}
```

遍历输出的组件中`key`是必需的，因为它是用来唯一标识组件的。


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

React Lists


Swift 中复杂类型包括：

- Array
- Set
- Tuple
- Dictionary
- Enums

### Array

> Swift 数组允许您存储相同类型的值，可以使用该值在数组中的位置来检索这些值。Swift 会强制检测元素类型，如果类型不同，会报错。

```swift
// 创建数组
var firstArray = ["hello","hello","world"]
var secondArray = ["swift","niubility"]

// 获取数组第一个元素
print(firstArray[0]) // hello

//添加数组
firstArray.append("manon")
firstArray+=["icu"]

// 循环数组
for item in firstArray{
	print(item) //hell hello world manon icu
}

// 修改数组元素
firstArray[0] = "swift"

// 合并数组
firstArray+secondArray

// 计算数组元素的个数
firstArray.count

// 判断数组是否为空
firstArray.isEmpty

// 删除数组元素
firstArray.remove(at: 0)
```

### Set

> 集合是用来存储类型相同且没有确定顺序的唯一的值，不允许插入已存在的值

```swift
// 创建集合
let firstSet = Set(["hello","world","manon","icu","swift"])
let secondSet = Set(["just","do","it"])

// 访问集合
for item in firstSet{
	print(item) //"hello","world","manon","icu","swift"
}

// 判断是否为空
firstSet.isEmpty // false

// 计算集合的长度
firstSet.count //5

// 判断是否包含某个元素
firstSet.contains("manon") //true

// 向集合添加元素
firstSet.insert("funny")

// 删除集合的元素
firstSet.remove("manon")

// 合并集合
firstSet.union(secondSet)
```

### Tuple

> Swift 中的 tuple 允许存储不同类型的固定数量的值。创建元组后，不能从该元组中添加或删除值。

```swift
// 创建tuple
let firstTuple = (name: "manon", level: 9000, Nationality: "china")

// 访问tuple
firstTuple.name // manon
```

### Dictionary

> Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。 Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。 Swift 字典的 key 没有类型限制可以是整型或字符串，但必须是唯一的。

```swift
// 创建字典
let firstDictionary = ["Gintama" : "Sakata Gintoki", "Haikyuu" : "Shoyo Hinata"]

// 访问字典
firstDictionary["Gintama"] // Sakata Gintoki

// 修改字典
firstDictionary.updateValue("manon",forKey:Gintama)
// 或
firstDictionary["Gintama"] = "manon"

// 删除字典元素
firstDictionary.removeValue("Gintama")

// 遍历字典
for (key,value) in firstDictionary{
	print("字典 key \(key) -  字典 value \(value)")
}

// 计算字典长度
firstDictionary.count

// 判断字典是否为空
firstDictionary.isEmpty
```

### Enums

> 根据 Swift 文档枚举的定义，它是“一组相关值的公共类型，使您能够在代码中以类型安全的方式处理这些值”。可以把它看作是一种特别用于 switch/conditions 的变量类型。

```swift
// 创建Enums
enum enumname {
   // 枚举定义放在这里
}

// 实例

import Cocoa

enum DaysofaWeek {
    case Sunday
    case Monday
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case Saturday
}

var weekDay = DaysofaWeek.THURSDAY
weekDay = .THURSDAY
switch weekDay{
	case .Sunday:
		print("星期天")
	case .Monday:
		print("星期一")
	case .TUESDAY:
		print("星期二")
	case .WEDNESDAY:
		print("星期三")
	case .THURSDAY:
		print("星期四")
	case .FRIDAY:
		print("星期五")
	case .Saturday:
		print("星期六")
}
```


Complex Types - 数组、字典、集合、枚举


闭包是一种自包含的函数，可以在代码中被传递和使用。闭包可以捕获和存储其所在上下文中的任何常量和变量的引用，因此被称为闭包，因为它们会封闭这些变量。Swift 中的闭包与 C 和 Objective-C 中的块（blocks）以及其他一些编程语言中的匿名函数类似。

以下是一个简单的示例，用于排序一个字符串数组：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

func backward(_ s1: String, _ s2: String) -> Bool {
  return s1 > s2
}

var reversedNames = names.sorted(by: backward)
```

在上面的示例中，backward 函数接受两个字符串参数，比较它们的大小，并返回一个布尔值，表示第一个字符串是否在第二个字符串之后。sorted 函数接受一个闭包作为参数，并使用该闭包对数组进行排序。由于 backward 函数符合 sorted 函数要求的类型，因此可以将 backward 函数作为 sorted 函数的参数传递。

在 Swift 中，可以使用闭包表达式来定义闭包。闭包表达式使用一对花括号（{}）来定义，并且在花括号中可以指定参数列表、返回类型和函数体。

以下是使用闭包表达式进行排序的示例：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

var reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
  return s1 > s2
})
```

在上面的示例中，sorted 函数的参数是一个闭包表达式。闭包表达式包含了与 backward 函数相同的代码，但是这些代码被写成了更简单的形式。闭包表达式使用一对花括号来定义闭包，并指定参数列表和返回类型。在闭包体中，可以使用 return 关键字来返回值。

Swift 中的闭包还有以下特点：

- 闭包表达式可以从上下文中推断出参数类型和返回类型，因此可以省略它们。
- 闭包表达式可以使用简写参数名，用 $0、$1、$2 等来代替参数名。
- 如果闭包表达式只包含一行代码，可以省略 return 关键字。
- 可以将闭包表达式作为函数的最后一个参数传递，并将其放在圆括号外面，以提高可读性。
  以下是使用闭包表达式进行排序的更简单的示例：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

var reversedNames = names.sorted(by: { $0 > $1 })
```

Swift 中的闭包是非常有用的工具，可以使代码更加简洁、可读和易于维护。


闭包是一种自包含的函数，可以在代码中被传递和使用

Swift - 闭包


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

条件语句是控制流的基础，它根据指定的条件来执行或跳过特定的代码块。在 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)
    }
}
```
