Looping - 循环


在做 UI（页面重构）的时候，免不了和各种小图标打交道，这其中最多的应该是三角形以及箭头，一般情况下可以通过伪类使用 unicode 解决大部分问题。

现在我们来总结下几种使用 css 绘制三角形的方法，dom 结构如下：

```html
<div class="triangle"></div>
```

## 最简单最方便的办法 background

```
代码忽略
```

## unicode

```css
.triangle:after {
  display: block;
  content: '\25B2';
  color: '#fd5353';
  font-size: 20px;
}
```

> 注意，伪类必须加上 content 属性，否则不生效

[unicode 图表](http://www.w3cplus.com/solution/css3content/images/html.png)

## border

```css
.triangle {
  width: 0;
  height: 0;
  border-left: 50px solid transparent;
  border-right: 50px solid transparent;
  border-bottom: 100px solid red;
}
```

使用 border 绘制三角形是什么原理？事实上，宽度相等的 border 是以 45 度对接的，如下图：

![image](https://i.stack.imgur.com/hZefy.png)

那么没有了上 border 就是如下图：

![image](https://i.stack.imgur.com/uV9Q5.png)

再设置 div 的宽度为 0，就是如下图：

![image](https://i.stack.imgur.com/K1A7G.png)

再设置 div 的高度为 0，如下图：

![image](https://i.stack.imgur.com/NsmsW.png)

最后设置左右 border 的颜色为透明，如下图：

![image](https://i.stack.imgur.com/B42zY.png)

再来个动图：

![image](https://i.stack.imgur.com/vYvqa.gif)

通过这种原理，我们可以做更多的图形，比如五角星、六角星等，更多图形请移步[shapesofcss](https://css-tricks.com/examples/ShapesOfcss/)

## 使用 css3 transform rotate

![image](https://i.stack.imgur.com/mEaS1.jpg)

```css
.triangle {
  width: 30%;
  padding-bottom: 21.27%; /* = width / 1.41 */
  position: relative;

  //划重点
  overflow: hidden;
}

.triangle: before {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background: #0079c6;

  //划重点
  transform-origin: 0 100%;
  transform: rotate(45deg);
}
```

> 为什么是 1.41，因为正方形的对角线长度是约等于 1.414。

## 使用 clip-path

```css
.triangle {
  width: 200px;
  height: 200px;
  background: #fd5353;
  clip-path: polygon(50% 0, 0 100%, 100% 100%);
}
```

clip-path 不支持安卓 4.4 以下，其余均需使用浏览器前缀-webkit，[caniuse](http://caniuse.com/#feat=css-clip-path)

详细请移步 [clip-path](https://developer.mozilla.org/zh-CN/docs/Web/css/clip-path)


在做UI（页面重构）的时候，免不了和各种小图标打交道，这其中最多的应该是三角形以及箭头

三角形绘制方法


ReactJS 是一个声明性、高效和灵活的 JavaScript 库，用于构建可重用的 UI 组件。这是一个开源的、基于组件的前端库，仅负责应用程序的视图层。它最初由 Facebook 开发和维护，后来用于 WhatsApp 和 Instagram 等产品。

## 前置技术

- babel
- webpack
- nodejs && npm
- html && css

## 基本概念

- <a href="/blog/react/React Elements">React Elements</a>
- <a href="/blog/react/React Elements Attributes">React Elements Attributes</a>
- <a href="/blog/react/React Elements Styles">React Elements Styles</a>
- <a href="/blog/react/React Fragments">React Fragments</a>
- <a href="/blog/react/React Components">React Components</a>
- <a href="/blog/react/React Props">React Props</a>
- <a href="/blog/react/React Children Props">React Children Props</a>
- <a href="/blog/react/React Conditionals">React Conditionals</a>
- <a href="/blog/react/React Lists">React Lists</a>
- <a href="/blog/react/React Context">React Context</a>
- <a href="/blog/react/React Hooks">React Hooks</a>


Learning React.js


协议（Protocol）是 Swift 中一种重要的类型，它描述了一种方法或者属性的集合。协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

协议定义了一些方法和属性，但不提供任何实现。实现协议的类型，必须遵循协议的要求并提供这些方法和属性的实际实现。

协议的语法如下：

```swift

protocol SomeProtocol {
// 协议定义
}
```

接下来，我们将了解协议的常见用法和特性。

## 协议的属性要求

协议可以要求实现者提供特定名字和类型的实例属性或类型属性。协议不指定属性是存储属性还是计算属性，只指定属性的名称和类型。此外，协议还要求属性是可读写的或只读的。

实现协议的类型，必须遵循协议的要求并提供这些属性的实际实现。如果协议要求实现的属性是可读写的，那么实现者必须提供一个可读写的属性实现；如果协议要求实现的属性是只读的，那么实现者可以提供一个可读的属性实现或一个只读的计算属性实现。

下面是一个协议属性要求的例子：

```swift

protocol Person {
var name: String { get set }
var age: Int { get }
}
```

这个协议定义了两个属性要求，name 和 age。name 是一个可读写的字符串类型的实例属性，age 是一个只读的整数类型的实例属性。

接下来，我们定义一个结构体 Student 来实现 Person 协议：

```swift

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

Student 结构体实现了 Person 协议，并提供了 name 和 age 属性的实现。由于 Person 协议要求 name 是可读写的，因此 Student 结构体提供了一个可读写的 name 属性实现。而 Person 协议要求 age 是只读的，因此 Student 结构体提供了一个只读的 age 属性实现。

## 协议的方法要求

协议可以要求实现者提供特定名字和类型的实例方法和类型方法。实现协议的类型，必须遵循协议的要求并提供这些方法的实际实现。

和属性要求一样，协议中的方法要求只定义方法名、参数以及返回类型，但不提供具体的实现。实现者必须自行实现这些方法。

下面是一个协议方法要求的例子：

当一个类型符合一个协议时，我们称这个类型为遵循该协议。协议定义了一组要求，遵循该协议的类型必须满足这些要求。

在 Swift 中，协议可以用来实现多态。这意味着，我们可以使用一个遵循该协议的实例来代替任何符合该协议的类型的实例，从而使代码更加通用。

下面是一些常见的协议和它们的使用方法：

## CustomStringConvertible

该协议可以让我们自定义类型的字符串描述。当我们打印一个遵循 CustomStringConvertible 协议的类型时，它将返回一个字符串描述。这在调试和日志记录时非常有用。

下面是一个实现 CustomStringConvertible 协议的例子：

```swift

struct Person: CustomStringConvertible {
let name: String
let age: Int

    var description: String {
        return "\(name), \(age) years old"
    }
}

let person = Person(name: "Alice", age: 28)
print(person) // Output: Alice, 28 years old
```

## Equatable

该协议可以让我们比较两个实例是否相等。当我们需要比较两个对象时，遵循 Equatable 协议的类型会自动获得 == 运算符的实现。

下面是一个实现 Equatable 协议的例子：

```swift

struct Point: Equatable {
let x: Int
let y: Int
}

let point1 = Point(x: 1, y: 2)
let point2 = Point(x: 1, y: 2)

if point1 == point2 {
print("The two points are equal.")
} else {
print("The two points are not equal.")
}
```

## Hashable

该协议可以让我们将一个类型实例转换为一个唯一的哈希值。遵循 Hashable 协议的类型可以用作字典的键或集合的元素。

下面是一个实现 Hashable 协议的例子：

```swift

struct User: Hashable {
let id: Int
let name: String
}

let user1 = User(id: 1, name: "Alice")
let user2 = User(id: 2, name: "Bob")

var userDict = [user1: "Alice", user2: "Bob"]
print(userDict[user1]) // Output: Optional("Alice")
```

## Codable

该协议可以让我们将一个类型编码为 JSON 或解码 JSON。遵循 Codable 协议的类型可以通过编码和解码操作在 Swift 和其他语言之间进行转换。

下面是一个实现 Codable 协议的例子：

```swift

struct Person: Codable {
let name: String
let age: Int
}

let person = Person(name: "Alice", age: 28)

let encoder = JSONEncoder()
let data = try encoder.encode(person)

let decoder = JSONDecoder()
let decodedPerson = try decoder.decode(Person.self, from: data)

print(decodedPerson) // Output: Person(name: "Alice", age: 28)
```


协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

Swift - 协议


## 浏览器扩展图标 - action

修改`public/manifest.json`

```json
{
  "action": {},
  "background": {
    "service_worker": "background.js"
  }
}
```

修改`public/background.js`

```js
chrome.action.onClicked.addListener(() => {
  chrome.tabs.create({url: './new-tab.html', active: true})
})
```

当点击图标，将会导航到新的选项卡

## Source Code

[【Source Code】](https://github.com/rebelchris/new-tab-extension/tree/action)


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

Chrome插件开发 - Icon action


> 作用域是管理变量可用性的一个重要概念。作用域在基本闭包处，定义了全局变量和局部变量的概念。

## 作用域 - The Scope

在深入理解作用域之前，先通过一个简单的例子看看是如何工作的。

```js
const message = 'hello'
console.log(message) // hello
```

你可以轻松访问`message`变量。

如果将`message`变量放在`if`语句内，比如：

```js
if (true) {
  const message = 'hello'
}
console.log(message) // ReferenceError: message is not defined
```

为什么？

`if` 代码块为消息变量创建一个作用域，而消息变量只能在这个作用域内访问。

![The Scope](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/7EzPUL.jpg)

在更高的级别上，变量的可访问性受到它们被创建的作用域的限制。您可以自由访问在其作用域内定义的变量。但是在它的作用域之外，变量是不可访问的。

## 块级作用域 - Block Scope

```js
if (true) {
  // if 块级作用域
  const message = 'hello'
  console.log(message) // hello
}
console.log(message) // ReferenceError: message is not defined
```

第一个`console.log`输出`hello`，因为`message`变量在`if`块级作用域内。

第二个`console.log`输出`ReferenceError: message is not defined`，因为`message`变量在`if`块级作用域之外。

`if`、`for`、`while`、`do`、`switch`、`with`、`function` 以及`catch`创建块级作用域。比如：

```js
for (const color of ['green', 'red', 'blue']) {
  // "for" block scope
  const message = 'Hi';
  console.log(color);   // 'green', 'red', 'blue'
  console.log(message); // 'Hi', 'Hi', 'Hi'
}
console.log(color);   // throws ReferenceError
console.log(message); // throws ReferenceError

while (/* condition */) {
  // "while" block scope
  const message = 'Hi';
  console.log(message); // 'Hi'
}
console.log(message); // => throws ReferenceError
```

### `var` 不是块级作用域

`var` 关键字不是块级作用域。比如：

```js
if (true) {
  // "if" block scope
  var count = 0
  console.log(count) // 0
}
console.log(count) // 0
```

使用`var`定义的变量，会产生变量提升，即变量会在它们被访问之前被创建。在除`function`外的所有块级作用域中，`var` 关键字都是不可访问的。

## 函数作用域 - Function Scope

```js
function run() {
  // "run" function scope
  var message = 'Run Forrest, run!'
  console.log(message) // Run Forrest, run!
}
run()
console.log(message) // ReferenceError: message is not defined
```

`run()`函数定义了一个块级作用域，它包含了`message`变量，`message`变量可以在`run()`函数内访问，但是不能在`run()`函数之外访问。

同样`let`和`const`也是块级作用域。可以在`run()`函数内访问， 但是不能在`run()`函数之外访问。

```js
function run() {
  // "run" function scope
  const two = 2
  let count = 0
  function run2() {}
  console.log(two) // 2
  console.log(count) // 0
  console.log(run2) // function
}
run()
console.log(two) // throws ReferenceError
console.log(count) // throws ReferenceError
console.log(run2) // throws ReferenceError
```

## 模块作用域 - Module Scope

ES2015 同样支持模块作用域。模块作用域是一个特殊的块级作用域，它可以在模块内部访问，但是不能在模块之外访问。

```js
// circle.js
const PI = 3.14
console.log(pi) // 3.14
```

`circle.js`模块定义了一个块级作用域，它包含了`PI`变量。但是未导出`PI`变量，因此不能在模块之外访问。

```js
import './circle'
consoel.log(pi) // throws ReferenceError
```

## 嵌套作用域 - Scopes can be nested

作用域可以嵌套。比如：

```js
function run() {
  // "run" function scope
  const message = 'Run, Forrest, Run!'
  if (true) {
    // "if" code block scope
    const friend = 'Bubba'
    console.log(message) // 'Run, Forrest, Run!'
  }
  console.log(friend) // throws ReferenceError
}
run()
```

`if`代码块作用域嵌套在`run()`函数作用域内。`if`代码块作用域内部可以访问`message`变量，但是不能`if`外部访问`friend`变量。

![Scopes can be nested](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/yE2fSE.jpg)

## 全局作用域 - Global Scope

全局作用域是一个特殊的作用域，它可以在整个程序的所有位置访问。`<script>`标签内的代码块是全局作用域。

```js
;<script src="myScript.js"></script>

// myScript.js
// 全局作用域
let counter = 1
```

在前面的代码片段中，`counter` 是一个全局变量。这个变量可以从网页的 JavaScript 的任何地方访问。

全局作用域是一种机制，它允许 JavaScript 的主机(浏览器、节点)为应用程序提供特定于主机的函数作为全局变量。

例如，`window` 和 `document` 是浏览器提供的全局变量。在 `Node` 环境中，可以将进程对象作为全局变量访问。

## 词法作用域 - Lexical Scope

定义两个函数，将函数`innerFunc`嵌套在函数`outerFunc`内部。

```js
function outerFunc() {
  // the outer scope
  let outerVar = 'I am from outside!'
  function innerFunc() {
    // the inner scope
    console.log(outerVar) // 'I am from outside!'
  }
  return innerFunc
}
const inner = outerFunc()
inner()
```

`inner()`函数执行时，`innerFunc()`函数定义了一个块级作用域，它包含了`outerVar`变量。

实际上是执行了`outerFunc`函数内的`innerFunc()`函数。`outerFunc`函数返回函数，形成了一个闭包。

所以`outerFunc`外部可以访问`innerFunc()`内部的`outerVar`变量。

## 变量隔离 - Variables isolation

您可以在不同的作用域中重用公共变量名(`count`、`index`、`current`、`value`、etc) ，而不会发生冲突。

`foo()`和`bar()`函数作用域有它们自己的。

```js
function foo() {
  // "foo" function scope
  let count = 0
  console.log(count) // 0
}
function bar() {
  // "bar" function scope
  let count = 1
  console.log(count) // 1
}
foo()
bar()
```


作用域


在 JavaScript 中，继承可以通过构造函数、原型链、实例、拷贝实现。

## 构造继承

构造继承是指创建一个新的对象，并将其父对象的属性和方法复制到新对象上，并对新对象进行初始化。

```js
// 定义父对象
function Person(name, age) {
  this.name = name
  this.age = age
}

Person.prototype.sayHello = function () {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`)
}

// 定义子对象
function Student(name, age, major) {
  Person.call(this, name, age)
  this.major = major
}

// 继承父对象的方法
Student.prototype = Object.create(Person.prototype)
Student.prototype.constructor = Student

// 定义子对象自己的方法
Student.prototype.study = function () {
  console.log(`I am studying ${this.major}.`)
}

const john = new Student('John Doe', 22, 'Computer Science')
john.sayHello()
john.study()
```

在这个示例中，通过将父对象的方法复制到子对象的原型链上，实现了构造继承。

## 原型继承

原型继承通过将子对象的原型指向父对象来实现继承。以下是一个简单的原型继承的例子：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log('My name is ' + this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child

Child.prototype.sayAge = function () {
  console.log('My age is ' + this.age)
}

var child = new Child('John', 25)
child.sayName() // My name is John
child.sayAge() // My age is 25
```

先定义了一个 Parent 函数，它有一个 name 属性和一个 sayName 方法。然后，我们定义了一个 Child 函数，该函数继承了 Parent 函数。我们在 Child 函数中通过调用 Parent.call(this, name) 来初始化 name 属性，并且在 Child.prototype 上添加了一个 sayAge 方法。最后，我们创建了一个 Child 的实例，可以使用继承过来的 sayName 方法和 sayAge 方法。

从 ECMAScript 6 开始，JavaScript 增加了 class 关键字，可以更方便地实现继承。

```js
class Parent {
  constructor(name) {
    this.name = name
  }

  sayName() {
    console.log(this.name)
  }
}

class Child extends Parent {
  constructor(name, age) {
    super(name)
    this.age = age
  }
}

var child = new Child('Tom', 20)
console.log(child.name) // Tom
console.log(child.age) // 20
child.sayName() // Tom
```

## 实例继承

原型链的实现原理是，每个对象都有一个指向它的构造函数的原型的指针，以及一个指向该对象的原型的指针，而原型对象又有自己的原型对象。通过这种方式，所有的对象都构成了一个原型链，我们可以通过在原型对象上定义属性和方法来让它们被所有对象继承。

例如，我们可以定义一个基础对象 Animal，并在其原型对象上定义一个 sayHello 方法：

```js
function Animal() {}
Animal.prototype.sayHello = function () {
  console.log('Hello, I am an animal.')
}
```

然后，我们可以定义一个继承 Animal 的对象 Dog：

```js
function Dog() {}
Dog.prototype = Object.create(Animal.prototype)
Dog.prototype.constructor = Dog
```

现在，我们可以创建一个 Dog 对象并调用 sayHello 方法：

```js
const dog = new Dog()
dog.sayHello() // 输出 "Hello, I am an animal."
```

由此可见，Dog 对象继承了 Animal 的 sayHello 方法。

## 拷⻉继承

拷贝继承是指通过复制一个对象的属性和方法到另一个对象中来实现继承。这种方法主要通过使用一个循环或工具函数，将父对象的属性复制到子对象中。但是，拷贝继承存在一些问题，例如无法在父对象中更改子对象的属性。因此，拷贝继承通常不是首选的继承方法。

以下是一个 JavaScript 拷贝继承的示例：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log(this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

// 将父对象的属性和方法复制到子对象上
for (var prop in Parent.prototype) {
  Child.prototype[prop] = Parent.prototype[prop]
}

var child = new Child('John', 30)
child.sayName() // 输出 'John'
console.log(child.age) // 输出 30
```

在上面的示例中，我们通过循环将父对象的属性和方法复制到了子对象的原型上，从而实现了拷贝继承。

## 原型 prototype 机制或 apply 和 call ⽅法去实现较简单，建议使⽤构造函数与原型混合⽅式

```js
function Parent() {
  this.name = 'wang'
}
function Child() {
  this.age = 28
}
Child.prototype = new Parent() //继承了Parent，通过原型
var demo = new Child()
alert(demo.age)
alert(demo.name) //得到被继承的属性
```


JavaScript 支持继承，这是指在一个对象（称为“子类”）中继承另一个对象的属性和方法（称为“父类”）