Posted on

金融市场体系

金融市场概念 🌟🌟🌟

what is 金融市场?
交易对象:金融资产
交易主体:供给方,需求方
定义:交易金融资产并确定金融资产价格的一种机制
三层含义:

Read more »

Posted on | In ,

工作需要，需要证券从业资格证
考试内容：

  1. 金融市场体系

    12

  2. 中国的金融市场与多层次资本市场

    31

  3. 证券市场主体

    44 重点

  4. 股票

    55 重点

  5. 债券

    59 重点

  6. 证券投资基金

    46 重点

  7. 金融衍生工具

    24 难点

  8. 金融风险管理

    37

Posted on | In

MBR和GPT磁盘分区表

目前存在的磁盘分区表主要是这两种格式,以前重装系统或者折腾双系统的时候总是对这块不求甚解,对于操作系统的学习又没有细化到磁盘的实际调度,所以对这块一直模模糊糊,总是凭借经验去处理.

MBR

MBR相对来说是比较落后的一种分区形式

主引导记录(446Byte)和分区表(64Byte)

分区表只能支持四组记录区,所以MBR最多只能支持(四个主分区或者扩展分区),所以这也是为什么windows主流分区就是CDEF四个分区

但是具体的需求不可能之用四个分区就直接满足的,就要通过扩展分区去实现分区的扩展,可以在扩展分区中再去划分逻辑分区,在扩展分区中再拿一个额外的扇区作分区表,记录逻辑分区的分区信息.

最后形成的逻辑结构就是:

P+P+P+E(L+…+L)

不管怎么分配四个一级分区的设备文件名是一定要预留的，比如说：

/dev/sda1

/dev/sda2

/dev/sda5

/dev/sda6

/dev/sda7

/dev/sda8

虽然在这里，系统只使用了一个主分区加一个扩展分区，但是sda3和sda4的设备名其实是已经预留好的，扩展分区的二级分区只能从sda5开始分配。

另外，扩展分区只能有一个，且扩展分区不能被格式化。如果扩展分区被强行格式化或者破坏掉，那么扩展分区内的所有逻辑分区都会被删除，因为所有逻辑分区的分区表是存放在扩展分区的。所以能够被格式化的只有主分区和逻辑分区。

GPT

MBR天生就有缺陷，就是MBR的分区表只有区区

Posted on | In

混入(Mixin)

核心思想

从组件中抽出公共部分,和vuex不同,Mixin抽离的数据和方法是独立的，组件使用相同的Mixin之后是不影响的。

大概就是组件的组件

偷一段官网的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 定义一个混入对象
var myMixin = {
  created: function () {
    this.hello()
  },
  methods: {
    hello: function () {
      console.log('hello from mixin!')
    }
  }
}

// 定义一个使用混入对象的组件
var Component = Vue.extend({
  mixins: [myMixin]
})

var component = new Component() // => "hello from mixin!"

选项合并

当组件和混入对象存在同名选项时

比如，数据对象在内部会进行递归合并，并在发生冲突时以组件数据优先。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var mixin = {
  data: function () {
    return {
      message: 'hello',
      foo: 'abc'
    }
  }
}

new Vue({
  mixins: [mixin],
  data: function () {
    return {
      message: 'goodbye',
      bar: 'def'
    }
  },
  created: function () {
    console.log(this.$data)
    // => { message: "goodbye", foo: "abc", bar: "def" }
  }
})

对于钩子函数则会合并成为一个数组,因此mixin中的钩子和组件本身的钩子都会被调用,但是mixin的钩子会先于自身钩子调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var mixin = {
  created: function () {
    console.log('混入对象的钩子被调用')
  }
}

new Vue({
  mixins: [mixin],
  created: function () {
    console.log('组件钩子被调用')
  }
})

// => "混入对象的钩子被调用"
// => "组件钩子被调用"

值为对象的选项，例如 methods、components 和 directives，将被合并为同一个对象。两个对象键名冲突时，取组件对象的键值对。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
var mixin = {
  methods: {
    foo: function () {
      console.log('foo')
    },
    conflicting: function () {
      console.log('from mixin')
    }
  }
}

var vm = new Vue({
  mixins: [mixin],
  methods: {
    bar: function () {
      console.log('bar')
    },
    conflicting: function () {
      console.log('from self')
    }
  }
})

vm.foo() // => "foo"
vm.bar() // => "bar"
vm.conflicting() // => "from self"

全局模式

Posted on | In

一直没有系统地学习Pyhthon，正好最近学校弄了一个Python的毕业实习，还是不喜欢听培训班的那一套，自购一本蟒蛇书，开始学习Python，此章伊始。

Posted on | In

其实主要的点是在memo,memo是React16.6.0推出的(另外一个主要的功能就是React.lazy())

memo其实就是PureComponent的Functional component版本

PureComponent的逻辑其实就是把props和state进行了一层浅比较,如果改变了,那么就调用render().如果没有或者只是包含的某个属性发生了改变,就不重新渲染,最后的目的其实就是实现性能的优化.

所以只推荐在拥有简单的props和state的时候,才推荐去使用PureComponent,一旦涉及复杂的数据结构,就有可能出现model层已经更新了,但是view层经过浅对比,觉得不用更新

所以就有forceUpdate( )这个函数来强制更新

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import React ,{Component,PureComponent} from 'react'
 
class Son extends PureComponent {
    constructor(props){
        super(props)
        this.state = {
           style:{ width:'100px',
            height:'100px',
            background: this.props.color  // props改变 state不会更新
        }}
    }
    render(){
        return(
            <div style = {this.state.style}>
            {console.log('Son render()')}
            </div>
        )
    }
    componentWillReceiveProps(props,state){
        this.forceUpdate()    // 每次传递属性时 都会强制渲染 并忽略shouldComponentUpdate
        if ( props.color === this.props.color ) return false;
        this.setState((pre)=>{
            let newStyle = {...pre.style}
            newStyle.background = props.color
            console.log(props.color)
            return {style:newStyle}
        })
    }
}
 
class Father extends Component {
    constructor(){
        super()
        this.state = {
            color :'pink' 
        }
    }
    changeColor = (color)=>{
        this.setState({
            color:color
        })
    }
    render(){
        return(
            <>
                {console.log('Father render')}
                <button onClick = {this.changeColor.bind(null,'black')}>blcak</button>
                <button onClick = {this.changeColor.bind(null,'pink')}>pink</button>
                <button onClick = {this.changeColor.bind(null,'yellow')}>yellow</button>
                <Son color = {this.state.color}></Son>
            </> 
        )
        
    }
 
}
 
export default Father

Memo其实大差不差

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import React from "react";

function Child({seconds}){
    console.log('I am rendering');
    return (
        <div>I am update every {seconds} seconds</div>
    )
};

function areEqual(prevProps, nextProps) {
    if(prevProps.seconds===nextProps.seconds){
        return true
    }else {
        return false
    }

}
export default React.memo(Child,areEqual)

useMemo

有一个问题就是，有时候父组件的某个state更新，导致整个父组件重新render，然后传给子组件的参数由于父组件的重新render导致地址发生了改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
const Child = memo(({data}) =>{
    console.log('child render...', data.name)
    return (
        <div>
            <div>child</div>
            <div>{data.name}</div>
        </div>
    );
})

const Hook =()=>{
    console.log('Hook render...')
    const [count, setCount] = useState(0)
    const [name, setName] = useState('rose')

    const data = {
        name
    }

    return(
        <div>
            <div>
                {count}
            </div>
            <button onClick={()=>setCount(count+1)}>update count </button>
            <Child data={data}/>
        </div>
    )
}

例如data重新被定义，所以data的内存地址发生了改变，导致Child组件重新render，但是data本身的值是没有发生改变的，很浪费

React提供了useMemo的方法，render的时候都会把值和上一次的值进行一个比对，如果值发生了变化在触发Child的render函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
const Child = memo(({data}) =>{
    console.log('child render...', data.name)
    return (
        <div>
            <div>child</div>
            <div>{data.name}</div>
        </div>
    );
})

const Hook =()=>{
    console.log('Hook render...')
    const [count, setCount] = useState(0)
    const [name, setName] = useState('rose')

   const data = useMemo(()=>{
        return {
            name
        }
    },[name])
    
    return(
        <div>
            <div>
                {count}
            </div>
            <button onClick={()=>setCount(count+1)}>update count </button>
            <Child data={data}/>
        </div>
    )
}

useCallback的用法（useMemo的语法糖）

useCallback（x=>console.log(x)，[m]）

等价于

useMemo（()=>(x)=>console.log(x)，[m]）