this的指向


`Streams` 允许从源读取数据或写入数据到目标对象。在`Node.js`中有四种 stream

- `Writeable`：可写
- `Readable`：可读
- `Duplex`：双向，即可用于读写
- `Transform`：根据输入计算输出

每种类型的`stream`都是`EventEmitter`实例，在不同的实例抛出多个事件。常用的事件：

- `data`：当数据可读抛出
- `end`：当数据读取结束
- `error`：当数据读取错误
- `finish`：在调用 `stream.end()` 方法之后，并且所有数据都已刷新到底层系统

## 读取数据

```js
var fs = require('fs')
var data = ''

// Create a readable stream
var readerStream = fs.createReadStream('input.txt')

// Set the encoding to be utf8.
readerStream.setEncoding('UTF8')

// Handle stream events --> data, end, and error
readerStream.on('data', function (chunk) {
  data += chunk
})

readerStream.on('end', function () {
  console.log(data)
})

readerStream.on('error', function (err) {
  console.log(err.stack)
})

console.log('Program Ended') // Program Ended Tutorials Point is giving self learning content to teach the world in simple and easy way!!!!!
```

## 写入数据

```js
var fs = require('fs')
var data = 'Simply Easy Learning'

// Create a writable stream
var writerStream = fs.createWriteStream('output.txt')

// Write the data to stream with encoding to be utf8
writerStream.write(data, 'UTF8')

// Mark the end of file
writerStream.end()

// Handle stream events --> finish, and error
writerStream.on('finish', function () {
  console.log('Write completed.')
})

writerStream.on('error', function (err) {
  console.log(err.stack)
})

console.log('Program Ended')
```

## Pipe-管道流

`pipe`是一种机制，我们将一个`stream`的输出作为另一个`stream`的输入。它通常用于从一个`stream`中获取数据，并将该`stream`的输出传递给另一个`stream`。`pipe`操作没有限制。

```js
var fs = require('fs')

var readerStream = fs.createReadStream('input.txt')
var writerStream = fs.createWriteStream('output.txt')

readerStream.pipe(writerStream)

console.log('Program Ended')
```

## 链式流

`chaining`是一种将一个`stream`的输出连接到另一个`stream`并创建多个`stream`操作链的机制，它通常用于管道操作。

```js
var fs = require('fs')
var zlib = require('zlib')

// Compress the file input.txt to input.txt.gz
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'))

console.log('File Compressed.')
```


Streams允许从源读取数据或写入数据到目标对象。

Node.js - Streams


css 选择器规定了 css 规则会被应用到哪些元素上。

## 通用选择器

通用选择器选择命名空间所有的元素，如果未提供命名空间，则选择文档所有元素。

```css
* {
  margin: 0;
  padding: 0;
}

#app * {
  box-sizing: border-box;
}
```

## ID 选择器

ID 选择器选择具有指定 ID 属性的元素。

```css
#app {
  background: #fff;
}
```

## 类选择器

类选择器选择具有特定名称的元素，如果未提供类名，则选择所有元素。

```css
.app {
  color: red;
}
```

## 属性选择器

属性选择器选择具有指定属性的元素。

```css
input[type='text'] {
  border: 1px solid #ccc;
}
```

## 元素选择器

元素选择器选择具有指定名称的元素。

```css
p {
  color: red;
}
```

## 子元素选择器

子元素选择器选择具有指定名称的元素的所有子元素。

```css
#app > a {
  color: red;
}
```

## 伪类选择器

伪类选择器选择具有指定名称的元素，如果未提供伪类名，则选择所有元素。

```css
.app:hover {
  color: red;
}
.app:after {
  content: '.';
}
```

## 组合选择器

组合选择器选择具有指定名称的元素，如果未提供组合选择器，则选择所有元素。

```css
/*选择命名空间所有的div、p*/
div,
p {
  color: red;
}
/*选择命名空间所有的 li*/
ul > li {
  color: red;
}
/*选择临近的p*/
div + p {
  color: red;
}
```


css选择器规定了css 规则会被应用到哪些元素上

css - Selectors


在 CSS 中，有多种不同的 sizing units（尺寸单位）可以用来定义元素的尺寸和位置，下面是一些常见的 sizing units：

- px（像素）：像素是 CSS 中最常用的尺寸单位之一，它指的是屏幕上的一个物理像素。因为像素是一个固定的尺寸，所以使用像素定义元素的大小可以确保它们在不同的设备上显示一致。
- %（百分比）：百分比单位是相对于父元素的大小来定义元素的尺寸。例如，如果一个元素的宽度设置为 50%，那么它的宽度将会是其父元素宽度的一半。
- em（字号）：em 是相对于元素的字体大小来定义尺寸的单位。例如，如果一个元素的字体大小为 16px，那么 1em 将等于 16px。
- rem（根字号）：rem 也是相对于字体大小来定义尺寸的单位，但是它是相对于根元素的字体大小来计算的。例如，如果根元素的字体大小为 16px，那么 1rem 将等于 16px。
- vw/vh（视窗宽度/高度）：vw 和 vh 是相对于视口宽度和高度来定义尺寸的单位。例如，如果一个元素的宽度设置为 50vw，那么它的宽度将会是视口宽度的一半。
- vmin/vmax（视口宽度/高度的较小或较大值）：vmin 和 vmax 也是相对于视口宽度和高度来定义尺寸的单位。vmin 指的是视口宽度和高度中较小的值，而 vmax 则指的是较大的值。

除了以上列举的 sizing units，CSS 还有一些其他的尺寸单位，如 pt（磅）、pc（派卡）等，但它们在网页设计中使用较少。需要注意的是，不同的 sizing units 适用于不同的场景，根据具体需求选择合适的尺寸单位来定义元素的尺寸和位置是非常重要的。

## 案例

以下是使用不同 sizing units 的 CSS 示例：

1. px（像素）

```css
div {
  width: 200px;
  height: 150px;
  font-size: 16px;
}
```

2. %（百分比）

```css
.parent {
  width: 500px;
  height: 300px;
}

.child {
  width: 50%;
  height: 50%;
}
```

3. em（字号）

```css
.parent {
  font-size: 16px;
}

.child {
  width: 10em;
  height: 5em;
}
```

4. rem（根字号）

```css
html {
  font-size: 16px;
}

.child {
  width: 20rem;
  height: 10rem;
}
```

5. vw/vh（视窗宽度/高度）

```css
.child {
  width: 50vw;
  height: 25vh;
}
```

6. vmin/vmax（视口宽度/高度的较小或较大值）

```css
.child {
  width: 50vmin;
  height: 50vmax;
}
```


css - 尺寸单位


在 Swift 中，访问控制是一种功能，它允许开发人员限制代码的某些部分从代码的其他部分或外部代码访问。这对于保持代码的完整性和安全性以及确保它以预期方式使用非常重要。

在 Swift 中，有五个访问控制级别：

- Public：这是最高级别的访问控制。标记为 public 的代码可以从程序的任何地方访问，包括其他模块和框架。
- Open：此级别类似于 public，但具有子类外部可覆盖方法和属性的功能。
- Internal：标记为 internal 的代码可以从同一模块内的任何位置访问，但无法从模块外访问。
- File-private：此级别仅限于当前源文件。标记为 file-private 的代码仅可从同一文件中访问。
- Private：这是最严格的访问控制级别。标记为 private 的代码只能从同一声明块中访问，例如类或结构体。

使用关键字（例如“public”，“private”，“fileprivate”，“internal”和“open”）指定访问控制。如果未指定访问级别，则默认为“internal”。访问控制可以应用于代码的各个部分，包括类、方法、属性和变量。

访问控制的目的是通过限制代码的访问和修改方式来帮助防止错误和安全漏洞。例如，通过将某些变量标记为 private，开发人员可以确保只能从同一类中修改它们，减少来自代码其他部分的意外修改的风险。同样，通过将某些方法标记为 public，开发人员可以确保它们可以从程序的任何地方调用，使它们更易于其他开发人员使用。


在 Swift 中，访问控制是一种功能，它允许开发人员限制代码的某些部分从代码的其他部分或外部代码访问。

Swift - 访问控制


## 输入值数字化

```js
const checkMyValueType = (event) => {
  console.log(typeof event.target.value) // string
  console.log(typeof event.target.valueAsNumber) // number
}
;<input type="number" onkeyup="checkMyValueType(event)" />
```

## 复制输入框值到粘贴板

```js
function copyToClipboard(inputID) {
  navigator.clipboard.writeText(document.querySelector(inputID).value)
}
```

## 检查窗口是否可见

```js
const isBrowserTabInView = () => document.hidden
isBrowserTabInView() // returns true or false depending if tab is in view / focus
```

## 布尔值取反

```js
let myBool = false
myBool = !myBool
console.log(myBool) // true
myBool = !myBool
console.log(myBool) // false
```

## 检查值是否是偶数

```js
const isEven = (num) => num % 2 === 0
console.log(isEven(2)) // true
console.log(isEven(3)) // false
```

## 检查日期是否是工作日

```js
const isWeekday = (d) => d.getDay() % 6 !== 0
console.log(isWeekday(new Date(2021, 0, 11))) // true (Monday)
console.log(isWeekday(new Date(2021, 0, 10))) // false (Sunday)
```

## 日期加减

```js
const addDaysToDate = (date, n) => {
  date.setDate(date.getDate() + n)
  return date.toISOString().split('T')[0]
}
addDaysToDate('2021-0-10', 10) // "2021-01-20"
addDaysToDate('2021-0-10', -10) // '2020-12-31'
```

## 获取时分秒

```js
const timeFromDate = (date) => date.toTimeString().slice(0, 8)
console.log(timeFromDate(new Date(2021, 0, 10, 17, 30, 0)))
// "17:30:00"
console.log(timeFromDate(new Date(2021, 0, 10, 5, 56, 44)))
// "05:56:44"
```

## 计算两个日期之间的工作日数

```js
const countWeekDaysBetween = (startDate, endDate) =>
  Array.from({length: (endDate - startDate) / (1000 * 3600 * 24)}).reduce(
    (count) => {
      if (startDate.getDay() % 6 !== 0) {
        count++
      }
      startDate = new Date(startDate.setDate(startDate.getDate() + 1))
      return count
    },
    0
  )
countWeekDaysBetween(new Date(2021, 0, 10), new Date(2021, 0, 20)) // 7
countWeekDaysBetween(new Date(2021, 1, 10), new Date(2021, 2, 18)) // 26
```

## 检查 localstorage 是否可用

```javascript
const isLocalStorageEnabled = () => {
  try {
    const key = `__storage__test`
    window.localStorage.setItem(key, null)
    window.localStorage.removeItem(key)
    return true
  } catch (e) {
    return false
  }
}
isLocalStorageEnabled() // true, if localStorage is accessible
```

## 计算函数等花费时间

```js
startTime = performance.now()
anyMethodOrCode()
const endTime = performance.now()
console.log(endTime - startTime + ' milliseconds.') // (Time in milliseconds)
```

## 捕获右键点击

```js
window.oncontextmenu = () => {
  console.log('right click')
}
```

## 只触发一次事件

```js
const myButton = document.getElementById('myBtn')
const myClickFunction = () => {
  console.log('this click will only get called once')
}
myButton.addEventListener('click', myClickHandler, {
  once: true
})
```

## 滚动到顶部

```js
const scrollToTopOfDocument = () => {
  const c = document.documentElement.scrollTop || document.body.scrollTop
  if (c > 0) {
    window.requestAnimationFrame(scrollToTop)
    window.scrollTo(0, c - c / 8)
  }
}
scrollToTopOfDocument()
```

## 检查字符串是否大写

```js
const isUpperCase = (str) => str === str.toUpperCase()
console.log(isUpperCase('string')) // false
console.log(isUpperCase('STRING')) // true
console.log(isUpperCase('5TR1NG')) // true
```

## 检查元素是否处于 focus 状态

```js
const elementIsInFocus = (el) => el === document.activeElement
elementIsInFocus(anyElement) // returns true if in focus, false if not in focus
```

## 查找数组间不同元素

```js
const differenceInArrays = (array1, array2) => {
  const set = new Set(array2)
  return array1.filter((x) => !set.has(x))
}
differenceInArrays(['apple', 'orange', 'banana'], ['apple', 'orange', 'mango']) // ["banana"]
differenceInArrays([10, 12, 5], [66, 10, 6]) // [12, 5]
```

## 移除事件监听

```js
const removeEventOffElement = (el, evt, fn, opts = false) =>
  el.removeEventListener(evt, fn, opts)
const testFunction = () => console.log('My function has been called')
document.body.addEventListener('click', testFunction)
// Call remove method
removeEventOffElement(document.body, 'click', fn)
```

## 随机生成 HEX 值

```js
const generateRandomColour = () =>
  '#' + Math.floor(Math.random() * 16777215).toString(16)
//EXAMPLE
document.getElementsByTagName('body')[0].style.color = generateRandomColour()
```

## 查找第一个定义的非空参数

```js
const getFirstValidValue = (...values) => values.find(v => ![undefined, null].includes(v));
console.log(getFirstValidValue(null, undefined, 'Hey', null); // 'Hey'
```

## 元素外部监听事件

```js
const onClickOutsideElement = (element, callback) => {
  document.addEventListener('click', (e) => {
    if (!element.contains(e.target)) callback()
  })
}
onClickOutside('#some-element', () => console.log('Hey you missed'))
// Will log "Hey you missed" everytime a click that was not "some-element" was clicked
```

## 总结

有时开发人员会发现自己在一次又一次地创建相同的东西，希望上面的一些代码片段可以在在开发中重用。最新的 JavaScript 特性和浏览器 api 是很重要的。


21个用于日常开发的有用JavaScript片段


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift 中的嵌套类型具有以下特性：

- 嵌套类型可以在外部类型中使用，可以像外部类型的属性或方法一样使用嵌套类型。
- 嵌套类型可以访问外部类型的所有成员，包括私有成员。
- 嵌套类型可以继承自外部类型，也可以作为外部类型的类型成员。

使用嵌套类型可以使代码更加有组织性，也可以减少全局作用域中的名称冲突。

以下是嵌套类型示例：

```swift
struct Outer {
    var outerProperty: Int

    struct Inner {
        var innerProperty: String
    }

    func outerMethod() {
        let outerInner = Inner(innerProperty: "Inner property")
        print("outerMethod called with inner property: \(outerInner.innerProperty)")
    }
}

let outer = Outer(outerProperty: 10)
let outerInner = Outer.Inner(innerProperty: "Inner property")
outer.outerMethod()  // 输出 "outerMethod called with inner property: Inner property"
```

在上面的示例中，Outer 的内部有一个嵌套类型 Inner。Inner 中有一个成员 innerProperty。outerMethod 可以访问 Inner，并使用它创建一个实例，然后访问其成员。在外部类型中，我们可以像使用普通类型一样使用 Inner。

另外，嵌套类型还可以被用于支持泛型类型的实现。当你定义一个泛型类型时，你可以定义嵌套类型作为泛型类型的一部分，这有助于在更加抽象化的层次上组织和定义代码，从而使泛型类型更加通用化和模块化。

以下是一个嵌套类型用于支持泛型的示例：

```swift
struct Container<T> {
    var value: T

    struct Nested {
        var nestedValue: T
    }

    var nested: Nested {
        return Nested(nestedValue: value)
    }
}

let container = Container(value: 42)
let nested = container.nested // 生成一个 nestedValue 为 42 的 Container.Nested 实例
```

在这个示例中，嵌套类型 Nested 中的成员 nestedValue 的类型与容器的泛型类型参数 T 一样。实例化容器时，使用 42 初始化元素 value，然后访问其嵌套类型 Nested。内部类型 Nested 通过嵌套容器类型的泛型类型参数 T 来支持类型实例化。

总之，在 Swift 中，嵌套类型有助于组织和定义代码，减少名称冲突，提高代码可读性和可管理性，并支持泛型类型实现。


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。