<script src="https://unpkg.com/vue@next"></script>

# 最新穩(wěn)定版
npm install vue@next
npm install -D @vue/compiler-sfc

npm install -g @vue/cli
vue upgrade --next

npm init vite@latest <project-name> -- --template vue
cd <project-name>
npm install
npm run dev

<script>
export default {
  setup (props, context) {
    return {}
  }
}
</script>

<script setup>
import {ref} from 'vue'
let property = ref('這里是響應式屬性');
// 這里我們引入了子組件SetUp.vue
import SetUp from '@/components/SetUp.vue'
</script>

<template>
    <h3>{{ state.count }}</h3>
    <h3>{{ num }}</h3>
    <el-button @click="handleAdd" type="primary">ref計算</el-button>
</template>

<script>
import { ref, reactive } from 'vue'

export default {
    setup() {
        const num = ref(0)
        const state = reactive({ count: 1 })
        function handleAdd() {
            state.count++;
            num.value += 2;
        }
        return {
            state,
            num,
            handleAdd
        }
    }
}
</script>

<template>
    <el-button @click="handleAdd" type="primary">ref計算</el-button>
    <h3>{{ obj.count }}</h3>
</template>

<script>
export default {
    setup() {
        // ref 對象雙向綁定
        const obj = ref({ count: 1 })
        function handleAdd() {
            obj.value.count = obj.value.count + 1
        }
        return {
            obj,
            handleAdd
        }
    }
}
</script>

<template>
    <div ref="root">This is a root element</div>
</template>
<script>
import {ref, watchEffect} from 'vue'
export default {
    setup() {
        const root = ref(null)
        watchEffect(() => {
            console.log(`watchEffect監(jiān)聽：${root.value}`);
        }, {
            flush: 'post'
        })
        return {
            root
        }
    },
}
</script>

<template>
    <h3>監(jiān)聽單個數(shù)據(jù)源1：{{state1.count}}</h3>
    <button @click="handleWatchSingle1">watch監(jiān)聽測試1</button>
    <h3>監(jiān)聽單個數(shù)據(jù)源2：{{state2}}</h3>
    <button @click="handleWatchSingle2">watch監(jiān)聽測試2</button>
    <h3>監(jiān)聽復雜對象數(shù)據(jù)源：{{state3.player}}</h3>
    <button @click="handleWatchSingle3">watch監(jiān)聽測試3</button>
</template>
<script>
import {ref, reactive, watch} from 'vue'

export default {
    setup() {
        const state1 = reactive({ count: 1 })
        const state2 = ref(0)
        const state3 = reactive({
            player: {
                name: 'James',
                achievement: ['4次NBA常規(guī)賽mvp', '03年選秀狀元', '4次NBA總冠軍']
            }
        })
        watch(() => state1.count, (newVal, oldVal) => {
            console.log('watch監(jiān)聽reactive中的newVal：', newVal);
            console.log('watch監(jiān)聽reactive中的oldVal：', oldVal);
        })
        watch(() => state2.value, (newVal, oldVal) => {
            console.log('watch監(jiān)聽ref中的newVal：', newVal);
            console.log('watch監(jiān)聽ref中的oldVal：', oldVal);
        })
        watch(() => state3.player, (newVal, oldVal) => {
            console.log('watch監(jiān)聽復雜對象中的newVal：', newVal);
            console.log('watch監(jiān)聽復雜對象中的oldVal：', oldVal);
        }, {
            deep: true,
            // immediate: true
        })
        // 同時監(jiān)聽多個值
        // watch([() => state1.count, state2.value], ([newVal1, newVal2], [oldVal1, oldVal2]) => {
        //     console.log('watch監(jiān)聽中的newVal：', newVal1, newVal2);
        //     console.log('watch監(jiān)聽oldVal：', oldVal1, oldVal2);
        // })
        function handleWatchSingle1() {
            state1.count++
        }
        function handleWatchSingle2() {
            state2.value++
        }
        function handleWatchSingle3() {
            state3.player = {
                name: 'Wade',
                achievement: ['3次NBA總冠軍', '曾經(jīng)的熱火三巨頭之一', '1次NBA總決賽mvp']
            }
        }
        return {
            state1,
            state2,
            state3,
            handleWatchSingle1,
            handleWatchSingle2,
            handleWatchSingle3
        }
    },
}
</script>

<template>
    <div style="margin-top:30">
        <h3>computedNum值為：{{computedNum}}</h3>
        <h3>computedNum2值為：{{computedNum}}</h3>
        <button @click="handleComputed">computed計算測試</button>
    </div>
</template>

<script>
import { ref, computed } from 'vue'

export default {
    setup() {
        const state = ref(1)
        const computedNum = computed(() => {
            return state.value + 1
        })
        console.log('computed緩存后的值：', computedNum.value);
        // 只可讀屬性，不可寫，會拋出警告 Write operation failed: computed value is readonly
        function handleComputed() {
            computedNum.value++
        }
        const computedNum2 = computed({
            get: () => state.value + 2,
            set: val => {
                count.value = val - 0
            }
        })
        return {
            computedNum,
            computedNum2,
            handleComputed
        }
    },
}
</script>

<template>
   <Children :msg1="msg1" :msg2="msg2" @childClick="handleClick" />
</template>
<script>
import {ref, reactive} from 'vue';
import Children from './children.vue'

export default {
    setup() {
        const msg1 = ref('給子組件傳遞的消息1')
        const msg2 = reactive({
            name: '給子組件傳遞的消息2'
        })
        return {
            msg1,
            msg2
        }
    },
    methods: {
        handleClick(val) {
            console.log('接收子組件emit過來的數(shù)據(jù)：', val);
        }
    },
    components: { Children }
}
</script>

<template>
    <div style="margin-top: 30px">props傳遞給子組件的消息：{{ msg1 }}</div>
    <button @click="$emit('childClick', 6666)" style="margin-top: 30px">向父組件emits事件</button>
</template>
<script>
export default {
    props: ['msg1', 'msg2'],
    emits: ['childClick'],
    setup(props) {
        console.log('子組件接收父級組件傳遞過來的消息：', props);
    },
}
</script>

<template>
    <slot name="title"></slot>
</template>

<template slot="title">
    <h2>周嶺：《認知覺醒》</h2>
<template>

<template>
    <!-- <slot name="title"></slot> -->
    <div v-for="(item, index ) in items" :key="index">
        <slot :item="item" name="content"></slot>
    </div>
</template>

<script setup>
import {ref} from 'vue';
const items = ref(['認知覺醒', '認知驅(qū)動']);
</script>

<template>
    <SlotChild>
        <!-- <template v-slot:content="scoped">
            <div>{{ scoped.item }}</div>
        </template> -->

        <template #content="{item}">
            <div>{{ item }}</div>
        </template>
    </SlotChild> 
</template>

<script setup>
import SlotChild from './SlotChild.vue'
</script>

<template>
    <div id="test">
        <h3>{{ counter }}</h3>
        <button @click="handleClick">聲明周期測試</button>
    </div>
</template>

<script>
import {
    ref,
    onMounted,
    onBeforeMount,
    onBeforeUpdate,
    onUpdated,
    onBeforeUnmount,
    onUnmounted
} from 'vue'
export default {
    setup() {
        const counter = ref(0);
        console.log('....');
        function handleClick() {
            counter.value += 1;
        }
        onBeforeMount(() => {
            console.log("組件掛載之前");
        });
        onMounted(() => {
            console.log("DOM掛載完成");
        });
        onBeforeUpdate(() => {
            console.log("DOM更新之前", document.getElementById("test").innerHTML);
        });
        onUpdated(() => {
            console.log("DOM更新完成", document.getElementById("test").innerHTML);
        });
        onBeforeUnmount(() => {
            console.log("實例卸載之前");
        });
        onUnmounted(() => {
            console.log("實例卸載之后");
        });
        return {
            counter,
            handleClick
        }
    },
}
</script>

// router/index.js
import Vue from 'vue'
import Router from 'vue-router'
import routes from './routes'

Vue.use(Router)

const router = new Router({
  routes
})
export default router

// main.js
import Vue from 'vue'
import router from './router'
// ...

new Vue({
  el: '#app',
  router,
  components: { App },
  template: '<App/>'
})

// router/index.js
import { createRouter } from 'vue-router'
import routes from './routes'

const router = createRouter({
  history: createWebHistory(), // history模式
  routes
})

// main.js
import { createApp } from 'vue'
import router from './router'

const app = createApp(App)
app.use(router)
app.mount('#app')

<template>
  <div class="mg30">
    <el-button @click="handleJump" type="primary">關(guān)于我們</el-button>
  </div>
</template>

<script setup>
import { useRouter } from 'vue-router'

const router = useRouter()

const handleJump = (query) => {
  router.push({ 
    name: "about", 
    query: {
      id: 1
    }
  }) 
}
</script>

<template>
    <div>關(guān)于我們</div>
</template>

<script setup>
import { useRoute } from 'vue-router'

const route = useRoute()
console.log('id>>>', route.query.id);
</script>

let routes = [
    {
        path: '/detail',
        name: 'detail',
        component: () => import('@/views/detail.vue'),
        meta: {
            needLogin: true
        }
    }
]

import router from './router'

// 全局路由守衛(wèi)
router.beforeEach((to, from) => {
    if (to.meta.needLogin) {
        return {
            name: 'login'
        }
    }
})

let routes = [
    {
        path: '/category/:id',
        name: 'category',
        component: () => import('@/views/category.vue'),
        beforeEnter: (to, from) => {
            // 如果不是正確的分類，跳轉(zhuǎn)到NotFound的頁面
            console.log('id>>>>', to.params.id);
            if (!["0", "1", "2"].includes(to.params.id)) { 
              return {
                name: "NotFound",
                // 這個是在地址欄保留輸入的信息，否則地址欄會非常的丑
                params: { pathMatch: to.path.split("/").slice(1) },
                query: to.query,
                hash: to.hash,
              };
            }
        }
    }
]

<template>
    <div>關(guān)于我們</div>
</template>

<script setup>
import { onBeforeRouteLeave, onBeforeRouteUpdate } from 'vue-router'


// 頁面內(nèi)部的路由守衛(wèi)
onBeforeRouteLeave((to, from) => {
    const answer = window.confirm('是否確認離開') 
    if (answer) { 
        console.log('不離開'); 
        return false 
    }
})

// 對于一個帶有動態(tài)參數(shù)的路徑 /category/:catId，在 /category/1 和 /category/2 之間跳轉(zhuǎn)的時候, 會觸發(fā)onBeforeRouteUpdate的路由鉤子函數(shù)，在鉤子函數(shù)中可以進行數(shù)據(jù)的更新。
onBeforeRouteUpdate((to, from) => {
     console.log('to>>>', to);
     console.log('from>>>', from);
    // if (to.params.id !== from.params.id) {
    //     userData.value = await fetchUser(to.params.id)
    // }
})
</script>

// vue-router 3
<keep-alive> 
 <router-view /> 
</keep-alive> 
 
// vue-router 4 
<router-view v-slot="{component}"> 
 <keep-alive> 
  <component :is="component" /> 
 </keep-alive> 
</router-view> 

<style scoped>
.parent :deep(div) {
    margin-bottom: 10px;
}
</style>

<template>
  <div class="parent">
    <div class="set-up">:deep 深度作用域測試</div>
  </div>
</template>

<template>
    <div>全局選擇器測試</div>
    <p :class="$style.green">module樣式測試</p>
</template>

<style scoped>
:global(div) {
    color: red;
}
</style>

<template>
    <p :class="$style.green">module樣式測試</p>
</template>

<style module>
.green {
    color: green;
}
</style>

<template>
    <p :class="classes.blue">useCssModule樣式測試</p>
</template>

<style module="classes">
.blue {
    color: blue;
}
</style>

<script>
import { h, useCssModule } from 'vue'
export default {
  setup() {
    const style = useCssModule()
    return () =>
      h(
        'div',
        {
          class: style.success
        },
        'Task complete!'
      )
  }
}
</script>

<style module>
.success {
  color: #090;
}
</style>

/**
 * @description: 基本的數(shù)據(jù)類型
 * @return {*} boolean（布爾值）number（數(shù)值） Array<number> （泛型數(shù)組）Object （對象）null undefined
 */
let isDone: boolean = false;
console.log('isDon', isDone);

let num: number = 1;
console.log('num', num);

let str: string = '認知覺醒';
console.log('str', str);

let arr: number[] = [1, 2, 3];
console.log('arr', arr);

// 泛型數(shù)組
let arr2: Array<number> = [1, 2, 3]
console.log('arr2', arr2);

let obj: Object = { id: 1 }
console.log('obj', obj);

let u: undefined = undefined
console.log('u', u);

let n: null = null;
console.log('n', n);

// 數(shù)字類型枚舉與數(shù)字類型
enum CardSuit {
    Clubs,
    Diamonds,
    Hearts,
    Spades
}

console.log('CardSuit', CardSuit.Clubs); // 0
let col = CardSuit.Clubs;
col = 0 // 安全有效的
console.log('col', col); // 0

// 數(shù)字類型枚舉與字符串類型
enum Tristate {
    False,
    True,
    Unkonw
}
console.log('字符串', Tristate[0]); // 'False'
console.log('number', Tristate['False']); // 0
console.log('字符串', Tristate[Tristate.False]); // 'False'

// 字符串枚舉
enum LogLevel {
    info = 'info',
    warn = 'warn',
    error = 'error'
}
console.log('LogLevel', LogLevel.info); // 'info'

/**
 * @description: 元祖
 * @return {*} 允許數(shù)組各元素的類型不必相同
 */
let x: [string, number, boolean];
x = ['hello', 10, true];
console.log('正確元祖', x); // ['hello', 10, true]
// y = [10, 'hello', false]
// console.log('錯誤的元祖', y);

/**
 * @description: 任意值 Any
 * @return {*} 表示任意類型, 通常用于不確定內(nèi)容的類型，比如用戶的輸入或者是第三方庫代碼；實際項目中，此類型建議少用
 */
let notSure: any = 4;
notSure = 'maybe a string instead';
console.log('notSure', notSure); // 'maybe a string instead'
notSure = true;
console.log('notSure', notSure); // true

/**
 * @description: 空值 void
 * @return {*} 與any相反，通常用于函數(shù)，表示沒有返回值
 */
const voidFunc = (): void => {
    console.log('這個函數(shù)沒有返回任何值');
    // return msg; // 不能return
}
voidFunc()

/**
 * @description: 接口 interface
 * @return {*} 類型契約，跟我們平時與服務端接口要先定義字段是一個道理
 */
interface Point {
    x: number
    y: number
    z?: number
    readonly l: number
}

const point: Point = { x: 10, y: 20, z: 30, l: 40 }
console.log('point', point);

const point2: Point = { x: '10', y: 20, z: 30 } // Error x應該是Number類型

const point3: Point = { x: 10, y: 20, z: 30 } // Error l字段也是必傳

const point4: Point = { x: 10, y: 20, z: 30, l: 40, m: 50 } // Error m字段沒有定義

const point5: Point = { x: 10, y: 20, l: 40 } // 正常
point5.l = 20; // Error l字段是只讀類型，不能修改

/**
 * @description: 函數(shù)參數(shù)類型與返回值類型
 * @return {*}
 */
function sum(a: number, b: number): number {
    return a + b;
}
console.log('sum', sum(2, 3)); // 5

// 配合interface使用
interface Point {
    x: number
    y: number
}

function sum2({x, y}: Point): number {
    return x + y;
}
console.log('sum2', sum2({x: 1, y: 2})); // 3

/**
 * @description: 泛型
 * @return {*} 泛型的意義在于函數(shù)的重用性，設(shè)計原則希望組件不僅能夠支持當前的數(shù)據(jù)類型，同時也支持未來的數(shù)據(jù)類型
 * 語法：<T>(arg: T): T
 */

// 比如我們最初設(shè)計函數(shù)identity 入?yún)镾tring
function identity(arg: String) {
    return arg;
}
console.log(identity('hello')); // hello

// 后來隨著業(yè)務的迭代我們又需要支持 Number
function identity2(arg: String) {
    return arg;
}
console.log(identity(2)); // Argument of type 'number' is not assignable to parameter of type 'String'

// 那我們?yōu)槭裁床挥胊ny呢？使用any會導致丟失掉一些信息，我們無法確定要返回值到底是屬于什么數(shù)據(jù)類型
const hello1: String = 'Hello vue3';
const hello2: Number = 666;
function say<T>(arg: T): T {
    return arg;
}
console.log('泛型1：', say(hello1)); // Hello vue3
console.log('泛型2：', say(hello2)); // 666

// 泛型約束
// 我們使用同樣的例子，加了一個console，但是很不幸運，報錯了，因為泛型無法保證每種類型都有.length 屬性
const hello3: String = 'Hello vue3';
function say2<T>(arg: T): T {
    console.log(arg.length); // Property 'length' does not exist on type 'T'
    return arg;
}
console.log('泛型3：', say2(hello3)); // Hello vue3

interface Lengthwise {
    length: number
}

function say3<T extends Lengthwise>(arg: T): T {
    console.log(arg.length);
    return arg;
}
console.log(say3(1)); // Argument of type 'number' is not assignable to parameter of type 'Lengthwise'.
console.log(say3({ value: 'hello vue', length: 10 })); // '{ value: 'hello vue', length: 10 }'

interface foo {
    x: number
}

interface bar {
    b: string
}

type intersection = foo & bar

const result: intersection = {
    x: 10,
    b: 'hello'
}

console.log('result', result);

/**
 * @description: 聯(lián)合類型
 * @return {*} 表示一個值可以為幾種數(shù)據(jù)類型之一
 */
type arg = string | number | boolean

const foo = (arg: arg): any => {
    console.log('arg', arg);
}
foo(1)
foo('1')
foo(true)

/**
 * @description: 函數(shù)重載
 * @return {*} 1個函數(shù)可以執(zhí)行多項任務的能力
 */

// add函數(shù)，它可以接收string類型的參數(shù)進行拼接，也可以接收number類型的參數(shù)進行相加
function add <T, U>(arg1: T, arg2: U) {
  // 在實現(xiàn)上我們要注意嚴格判斷兩個參數(shù)的類型是否相等，而不能簡單的寫一個 arg1 + arg2
  if (typeof arg1 === 'string' && typeof arg2 === 'string') {
    return arg1 + arg2
  } else if (typeof arg1 === 'number' && typeof arg2 === 'number') {
    return arg1 + arg2
  }
}
console.log('number類型相加', add(1, 2));
console.log('string類型拼接', add('1', '2'));

npm i typescript

{
  "compilerOptions": {
    "target": "esnext",
    "module": "esnext",
    "sourceMap": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "moduleResolution": "node",
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"]
}

<template>
   <div>
    <h2>標題：{{book.title}}</h2>
    <h2>作者：{{book.author}}</h2>
    <h2>出版日期：{{book.year}}</h2>
    <hr>
    <h3>{{allTitle}}</h3>
    <el-button @click="setTitle('我是傳入的數(shù)據(jù)')" type="primary">設(shè)置數(shù)據(jù)</el-button>
  </div>
</template>

<script lang="ts">
import { defineComponent, ref, toRefs, reactive } from 'vue';

// 定義Book接口
interface Book {
    title: String
    author: String
    year?: Number,
    handleChangeName?(): void
}
      
export default defineComponent ({
    data() {
        let book: Book = {
            title: 'vue3 typescript',
            author: "vue Team",
            year: 2020,
        }
        return {
            book
        }
    },
    setup() {
        let year1 = ref<String | Number>('2022')
        console.log('year1', year1.value);
        
        // 第一種方式
        // const book1: Book = reactive({
        // name: year1.value,
        // desc: "vue3 進階學習加油",
        // setNamechange(){
        //     this.name = "我是新設(shè)置的"
        // }
        // });
        // // 第二種方式
        // const book2 = reactive<Book>({
        // name: "vue3--typeScript",
        // desc: "學習ts加油",
        // year: 2020,
        // });
        // // 第三種方式
        // const book3 = reactive({
        //     name: "vue3--typeScript-第三種方式",
        //     desc: "ts類型第三種方式",
        //     year: 2022,
        // }) as Book;
    
        return {
            // ...toRefs(book1),
            // book2,
            // book3,
            // year1,
        };
    },
    computed: {
        // 返回值類型為String
        allTitle(): String {
            return `歡迎語 ： ${this.book.title}`
        }
    },
    methods: {
        // 入?yún)镾tring 返回空值
        setTitle(arg: String): void {
            this.book.title = arg;
            this.book.year = 2022
            this.book.author = '尤雨溪'
        }
    }
})
</script>