天天看點
傳回

前端之Vue.js庫的使用

vue.js簡介

Vue.js讀音 /vjuː/, 類似于 view

Vue.js是前端三大新架構：Angular.js、React.js、Vue.js之一，Vue.js目前的使用和關注程度在三大架構中稍微勝出，并且它的熱度還在遞增。

Vue.js可以作為一個js庫來使用，也可以用它全套的工具來建構系統界面，這些可以根據項目的需要靈活選擇，是以說，Vue.js是一套建構使用者界面的漸進式架構。

Vue的核心庫隻關注視圖層，Vue的目标是通過盡可能簡單的 API 實作響應的資料綁定，在這一點上Vue.js類似于背景的模闆語言。

Vue也可以将界面拆分成一個個的元件，通過元件來建構界面，然後用自動化工具來生成單頁面(SPA - single page application)系統。

Vue.js使用文檔及下載下傳Vue.js

Vue.js使用文檔已經寫的很完備和詳細了，通過以下位址可以檢視：https://cn.vuejs.org/v2/guide/

vue.js如果當成一個庫來使用，可以通過下面位址下載下傳：https://cn.vuejs.org/v2/guide/installation.html

Vue.js基本概念

首先通過将vue.js作為一個js庫來使用，來學習vue的一些基本概念，我們下載下傳了vue.js後，需要在頁面上通過script标簽引入vue.js，開發中可以使用開發版本vue.js，産品上線要換成vue.min.js。

<script type="text/javascript" src="js/vue.min.js"></script>　

Vue執行個體

每個 Vue 應用都是通過執行個體化一個新的 Vue對象開始的：

window.onload = function(){
    var vm = new Vue({
        el:'#app',
        data:{message:'hello world!'}
    });
}    
......

<div id="app">{{ message }}</div>

其中，el屬性對應一個标簽，當vue對象建立後，這個标簽内的區域就被vue對象接管，在這個區域内就可以使用vue對象中定義的屬性和方法。

資料與方法

當一個 Vue 執行個體被建立時，它向 Vue 的響應式系統中加入了其data對象中能找到的所有的屬性。當這些屬性的值發生改變時，視圖将會産生“響應”，即比對更新為新的值。還可以在Vue執行個體中定義方法，通過方法來改變執行個體中data對象中的資料，資料改變了，視圖中的資料也改變。

window.onload = function(){
    var vm = new Vue({
        el:'#app',
        data:{message:'hello world!'},
        methods:{
            fnChangeMsg:function(){
                this.message = 'hello Vue.js!';
            }
        }
    });
}    
......

<div id="app">
    <p>{{ message }}</p>
    <button @click="fnChangeMsg">改變資料和視圖</button>
</div>

Vue.js模闆文法

模闆文法指的是如何将資料放入html中，Vue.js使用了基于 HTML的模闆文法，允許開發者聲明式地将DOM綁定至底層 Vue 執行個體的資料。所有 Vue.js的模闆都是合法的 HTML ，是以能被遵循規範的浏覽器和 HTML 解析器解析。

插入值

資料綁定最常見的形式就是使用“Mustache”文法 (雙大括号) 的文本插值：

<span>Message: {{ msg }}</span>

如果是标簽的屬性要使用值，就不能使用“Mustache”文法，需要寫成使用v-bind指令：

<a v-bind:href="url" v-bind:title='tip'>百度網</a>

插入的值當中還可以寫表達式：

{{ number + 1 }}
{{ ok ? 'YES' : 'NO' }}
{{ message.split('').reverse().join('') }}
<a v-bind:href="url">連結文字</a>　　

指令

指令 (Directives) 是帶有“v-”字首的特殊屬性。指令屬性的值預期是單個JavaScript表達式，指令的職責是，當表達式的值改變時，将其産生的連帶影響，響應式地作用于DOM。常見的指令有v-bind、v-if、v-on。

<!-- 根據ok的布爾值來插入/移除 <p> 元素 -->
<p v-if="ok">是否顯示這一段</p>

<!-- 監聽按鈕的click事件來執行fnChangeMsg方法 -->
<button v-on:click="fnChangeMsg">按鈕</button>

縮寫

v-bind和v-on事件這兩個指令會經常用，是以有簡寫方式：

<!-- 完整文法 -->
<a v-bind:href="url">...</a>

<!-- 縮寫 -->
<a :href="url">...</a>


<!-- 完整文法 -->
<button v-on:click="fnChangeMsg">按鈕</button>

<!-- 縮寫 -->
<button @click="fnChangeMsg">按鈕</button>　

計算屬性和偵聽屬性

計算屬性

模闆内的表達式非常便利，但是設計它們的初衷是用于簡單運算的。在模闆中放入太多的邏輯會讓模闆過重且難以維護。例如：

<div id="example">
  {{ message.split('').reverse().join('') }}
</div>

這個表達式的功能是将message字元串進行反轉，這種帶有複雜邏輯的表達式，我們可以使用計算屬性

<div id="example">
  <p>Original message: "{{ message }}"</p>
  <p>Computed reversed message: "{{ reversedMessage }}"</p>
</div>

......

var vm = new Vue({
  el: '#example',
  data: {
    message: 'Hello'
  },
  computed: {
    // 計算屬性的 getter
    reversedMessage: function () {
      // `this` 指向 vm 執行個體
      return this.message.split('').reverse().join('')
    }
  }
})　

偵聽屬性

偵聽屬性的作用是偵聽某屬性值的變化，進而做相應的操作，偵聽屬性是一個對象，它的鍵是要監聽的對象或者變量，值一般是函數,當你偵聽的元素發生變化時，需要執行的函數，這個函數有兩個形參，第一個是目前值，第二個是變化後的值。

indow.onload = function(){
    var vm = new Vue({
        el:'#app',
        data:{
            iNum:1
        },
        watch:{
            iNum:function(newval,oldval){
                console.log(newval + ' | ' + oldval) 
            }
        },
        methods:{
            fnAdd:function(){
                this.iNum += 1;
            }
        }
    });
}

　　

Class 與 Style 綁定

使用v-bind指令來設定元素的class屬性或者sytle屬性，它們的屬性值可以是表達式，vue.js在這一塊做了增強，表達式結果除了是字元串之外，還可以是對象或者數組。

Class綁定

對象文法

可以給v-bind:class傳一個對象，以動态的切換class

<div class="static" v-bind:class="{active:isActive,'text-danger':hasError }"></div>

data屬性值如下：

data: {
  isActive: true,
  hasError: false
}

最終渲染的效果：

<div class="static active"></div>

也可以給v-bind:class傳一個對象引用

<div v-bind:class="classObject"></div>

data屬性值可以寫成：

data: {
  classObject: {
    active: true,
    'text-danger': false
  }
}　

數組文法

可以給v-bind:class傳一個數組，以應用一個 class 清單

<div v-bind:class="[activeClass, errorClass]"></div>
......

data: {
  activeClass: 'active',
  errorClass: 'text-danger'
}

最終渲染為：

<div class="active text-danger"></div>

如果你也想根據條件切換清單中的 class，可以用三元表達式：

<div v-bind:class="[isActive ? activeClass : '', errorClass]"></div>

不過，當有多個條件class時這樣寫有些繁瑣。是以在數組文法中也可以使用對象文法：

<div v-bind:class="[{ active: isActive }, errorClass]"></div>

style綁定

v-bind:style 的對象文法十分直覺——看着非常像 CSS，但其實是一個JavaScript 對象。CSS 屬性名可以用駝峰式 (camelCase) 來命名：

<div v-bind:style="{color: activeColor, fontSize: fontSize + 'px' }"></div>

data資料如下：

data: {
  activeColor: 'red',
  fontSize: 30
}

也可以給v-bind:style傳一個對象引用

<div v-bind:style="styleObject"></div>
      
data: {
  styleObject: {
    color: 'red',
    fontSize: '13px'
  }
}

v-bind:style 的數組文法可以将多個樣式對象應用到同一個元素上：

<div v-bind:style="[baseStyles, overridingStyles]"></div>　

條件渲染

通過條件指令可以控制元素的建立(顯示)或者銷毀(隐藏)，常用的條件指令如下：

v-if

v-if可以控制元素的建立或者銷毀

<h1 v-if="ok">Yes</h1>

v-else

v-else指令來表示 v-if 的“else 塊”，v-else 元素必須緊跟在帶 v-if 或者 v-else-if 的元素的後面，否則它将不會被識别。

<div v-if="Math.random() > 0.5">
  Now you see me
</div>
<div v-else>
  Now you don't
</div>

v-else-if

v-else-if，顧名思義，充當 v-if 的“else-if 塊”，可以連續使用：

<div v-if="type === 'A'">
  A
</div>
<div v-else-if="type === 'B'">
  B
</div>
<div v-else-if="type === 'C'">
  C
</div>
<div v-else>
  Not A/B/C
</div>　

v-show

另一個用于根據條件展示元素的選項是 v-show 指令。用法和v-if大緻一樣，但是它不支援v-else,它和v-if的差別是，它制作元素樣式的顯示和隐藏，元素一直是存在的：

<h1 v-show="ok">Hello!</h1>

清單渲染

通過v-for指令可以将一組資料渲染到頁面中，資料可以是數組或者對象，v-for 指令需要使用 item in items 形式的特殊文法，items 是源資料數組并且 item 是數組元素疊代的别名。

周遊數組 

<ul id="example-1">
  <li v-for="item in items">
    {{ item}}
  </li>
</ul>

vue對象建立如下：

var example1 = new Vue({
  el: '#example-1',
  data: {
    items: ['foo','bar']
  }
})

如果想加上索引值，可以加上第二個參數

<ul id="example-2">
  <li v-for="(item, index) in items">
    {{ index }} - {{ item.message }}
  </li>
</ul>

周遊對象

也可以用 v-for 通過一個對象的屬性來疊代

<ul id="v-for-object">
  <li v-for="value in object">
    {{ value }}
  </li>
</ul>

如果想加上對象屬性名，可以加上第二個參數

<ul id="v-for-object">
  <li v-for="(value,key) in object">
    {{ key }}-{{ value }}
  </li>
</ul>

事件處理

事件綁定方法

可以用 v-on 指令監聽 DOM 事件，并在觸發時運作一些 JavaScript 代碼，事件的處理，簡單的邏輯可以寫在指令中，複雜的需要在vue對象的methods屬性中指定處理函數。

<div id="example-1">
  <!-- 在指令中寫處理邏輯 -->
  <button v-on:click="counter += 1">Add 1</button>
  <p>The button above has been clicked {{ counter }} times.</p>
</div>
......
var example1 = new Vue({
  el: '#example-1',
  data: {
    counter: 0
  }
})

methods屬性中指定處理函數：

<div id="example-2">
  <!-- greet 是在下面定義的方法名 -->
  <button v-on:click="greet">Greet</button>
</div>
......

var example2 = new Vue({
  el: '#example-2',
  data: {
    name: 'Vue.js'
  },
  // 在 `methods` 對象中定義方法
  methods: {
    greet: function () {
      // `this` 在方法裡指向目前 Vue 執行個體
      alert('Hello ' + this.name + '!')
    }
  }
})

事件修飾符

實際開發中，事件綁定有時候牽涉到阻止事件冒泡以及阻止預設行為，在vue.js可以加上事件修飾符

<!-- 阻止單擊事件繼續傳播 -->
<a v-on:click.stop="doThis"></a>

<!-- 送出事件不再重載頁面 -->
<form v-on:submit.prevent="onSubmit"></form>

<!-- 修飾符可以串聯 -->
<a v-on:click.stop.prevent="doThat"></a>

<!-- 隻有修飾符 -->
<form v-on:submit.prevent></form>

表單輸入綁定

可以用 v-model 指令在表單 <input> 及 <textarea> 元素上建立雙向資料綁定。它會根據控件類型自動選取正确的方法來更新元素

單行文本框 

<input v-model="message" placeholder="edit me">
<p>Message is: {{ message }}</p>

多行文本框 

<span>Multiline message is:</span>
<p>{{ message }}</p>
<textarea v-model="message" placeholder="add multiple lines"></textarea>

複選框

單個複選框，綁定到布爾值：

<input type="checkbox" id="checkbox" v-model="checked">
<label for="checkbox">{{ checked }}</label>

多個複選框，綁定到同一個數組：

<div id='example-3'>
  <input type="checkbox" id="jack" value="Jack" v-model="checkedNames">
  <label for="jack">Jack</label>
  <input type="checkbox" id="john" value="John" v-model="checkedNames">
  <label for="john">John</label>
  <input type="checkbox" id="mike" value="Mike" v-model="checkedNames">
  <label for="mike">Mike</label>
  <br>
  <span>Checked names: {{ checkedNames }}</span>
</div>

......

new Vue({
  el: '#example-3',
  data: {
    checkedNames: []
  }
})

單選框 

<div id="example-4">
  <input type="radio" id="one" value="One" v-model="picked">
  <label for="one">One</label>
  <br>
  <input type="radio" id="two" value="Two" v-model="picked">
  <label for="two">Two</label>
  <br>
  <span>Picked: {{ picked }}</span>
</div>

......
new Vue({
  el: '#example-4',
  data: {
    picked: ''
  }
})

下拉框 

<div id="example-5">
  <select v-model="selected">
    <option disabled value="">請選擇</option>
    <option>A</option>
    <option>B</option>
    <option>C</option>
  </select>
  <span>Selected: {{ selected }}</span>
</div>
......

new Vue({
  el: '...',
  data: {
    selected:''
  }
})

過濾器

Vue.js允許你自定義過濾器，可被用于一些常見的文本格式化。過濾器可以用在兩個地方：雙花括号插值和 v-bind 表達式

<!-- 在雙花括号中 -->
{{ prize | RMB }}

<!-- 在v-bind中 -->
<div v-bind:id="rawId | formatId"></div>

過濾器實際上是一個函數，可以在一個元件的選項中定義元件内部過濾器：

filters:{
  RMB:function(value){
    if(value=='')
    {
      return;
    }
    return '¥ '+value;
  }
}

或者在建立 Vue 執行個體之前全局定義過濾器：

Vue.filter('Yuan',function(value){
  if(value=='')
  {
    return;
  }
  return value+'元';
});

此時過濾器'RMB'隻能在定義它的對象接管标簽内使用，而'Yuan'可以全局使用

自定義指令

指令是用來做dom操作的，如果vue現有的指令不能滿足開發要求，我們需要對普通DOM元素進行底層操作，這時候就會用到自定義指令。

定義一個全局指令，讓input框自動擷取焦點

Vue.directive('focus',{
  inserted:function(el,binding){
    el.focus();
    el.style.background = 'gold';
    console.log(binding.name);
  }     
})
......

<div id="app">    
  <input type="text" v-focus>
</div>

如果定義成vue對象局部的，可以用vue對象的directives屬性：

directives: {
  focus: {
    inserted: function (el,binding) {
      el.focus();
      el.style.background = 'gold';
      console.log(binding.name);
    }
  }
}　

執行個體生命周期

每個Vue執行個體在被建立時都要經過一系列的初始化過程——例如，需要設定資料監聽、編譯模闆、将執行個體挂載到DOM并在資料變化時更新 DOM 等。同時在這個過程中會自動運作一些叫做生命周期鈎子的函數，我們可以使用這些函數，在執行個體的不同階段加上我們需要的代碼，實作特定的功能。

beforeCreate

在執行個體初始化之後，資料觀測 (data observer) 和 event/watcher 事件配置之前被調用。

created

在執行個體建立完成後被立即調用。在這一步，執行個體已完成以下的配置：資料觀測 (data observer)，屬性和方法的運算，watch/event 事件回調。然而，挂載階段還沒開始

beforeMount

在挂載開始之前被調用：相關的 render 函數首次被調用。

mounted

執行個體挂載到dom之後被調用，可以當成是vue對象的ready方法來使用，一般用它來做dom的初始化操作。

beforeUpdate

資料發生變化前調用

updated

資料發生變化後調用

前端之Vue.js庫的使用

資料互動

vue.js沒有內建ajax功能，要使用ajax功能，可以使用vue官方推薦的axios.js庫來做ajax的互動。 axios庫的下載下傳位址：https://github.com/axios/axios/releases

axios完整寫法： 

axios({
  method: 'post',
  url: '/user/12345',
  data: {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }
});

axios請求的寫法也可寫成get方式或post方式。

執行get請求 

// 為給定 ID 的 user 建立請求
// then是請求成功時的響應，catch是請求失敗時的響應

axios.get('/user?ID=12345')
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});


// 可選地，上面的請求可以這樣做
axios.get('/user', {
  params: {
    ID: 12345
  }
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});　　

執行post請求 

axios.post('/user', {
  firstName: 'Fred',
  lastName: 'Flintstone'
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});　

ES6文法

ES6是JavaScript語言的新版本，它也可以叫做ES2015，之前學習的JavaScript屬于ES5，ES6在它的基礎上增加了一些文法，ES6是未來JavaScript的趨勢，而且vue元件開發中會使用很多的ES6的文法，是以掌握這些常用的ES6文法是必須的。

變量聲明let和const

let和const是新增的聲明變量的開頭的關鍵字，在這之前，變量聲明是用var關鍵字，這兩個關鍵字和var的差別是，它們聲明的變量沒有預解析，let和const的差別是，let聲明的是一般變量，const申明的常量，不可修改。

alert(iNum01) // 彈出undefined
// alert(iNum02); 報錯，let關鍵字定義變量沒有變量預解析
// alert(iNum03); 報錯，const關鍵字定義變量沒有變量預解析

var iNum01 = 6;
// 使用let關鍵字定義變量
let iNum02 = 12;
// 使用const關鍵字定義變量
const iNum03 = 24;

alert(iNum01); // 彈出6
alert(iNum02); // 彈出12
alert(iNum03); // 彈出24

iNum01 = 7;
iNum02 = 13;
//iNum03 = 25; // 報錯,const定義的變量不可修改,const定義的變量是常量

alert(iNum01)
alert(iNum02); 
alert(iNum03);　

箭頭函數

可以把箭頭函數了解成匿名函數的第二種寫法，箭頭函數的作用是可以在對象中綁定this，解決了JavaScript中this指定混亂的問題。

// 定義函數的一般方式
/*
function fnRs(a,b){
    var rs = a + b;
    alert(rs);
}
fnRs(1,2);        
*/

// 通過匿名函數指派來定義函數
/*
var fnRs = function(a,b){
    var rs = a + b;
    alert(rs);
}
fnRs(1,2);
*/

// 通過箭頭函數的寫法定義
var fnRs = (a,b)=>{
    var rs = a + b;
    alert(rs);
}        
// fnRs(1,2);

// 一個參數可以省略小括号
var fnRs2 = a =>{
    alert(a);
}
fnRs2('haha!');


// 箭頭函數的作用，可以綁定對象中的this
var person = {
    name:'tom',
    age:18,
    showName:function(){
        setTimeout(()=>{
            alert(this.name);
        },1000)            
    }
}
person.showName();　

子產品導入import和導出export

javascript之前是沒有子產品的功能的，之前做js子產品化開發，是用的一些js庫來模拟實作的，在ES6中加入了子產品的功能，和python語言一樣，python中一個檔案就是一個子產品，ES6中，一個js檔案就是一個子產品，不同的是，js檔案中需要先導出(export)後，才能被其他js檔案導入(import)

// model.js檔案中導出
var person = {name:'tom',age:18}
export default {person}

// index.js檔案夾中導入
import person from 'js/model.js'

// index.js中使用子產品
person.name
person.age

/*
上面導出時使用了default關鍵字，如果不使用這個關鍵字，導入時需要加大括号：
import {person} from 'js/model.js'
*/　

目前ES6的子產品功能需要在伺服器環境下才可以運作。

對象的簡寫

javascript對象在ES6中可以做一些簡寫形式，了解這些簡寫形式，才能友善我們讀懂一些在javascript代碼中簡寫的對象。

let name = '李思';
let age = 18;

/*
var person = {
    name:name,
    age:age,
    showname:function(){
        alert(this.name);
    },
    showage:function(){
        alert(this.age);
    }
}
*/

// 簡寫成下面的形式
var person = {
    name,
    age,
    showname(){
      alert(this.name);
    },
    showage(){
      alert(this.age);
    }
}

person.showname();
person.showage();

vue元件

元件(Component)是Vue.js最強大的功能之一。元件可以擴充 HTML 元素，封裝可重用的代碼。所有的 Vue 元件同時也都是 Vue 的執行個體，是以可接受相同的選項對象 (除了一些根級特有的選項) 并提供相同的生命周期鈎子。

注冊及使用元件 

// 注冊一個元件：
Vue.component('my-component', {
  template: '<div>A custom component!</div>'
})

//使用元件
<div id="example">
  <my-component></my-component>
</div>
......

new Vue({
  el: '#example'
})　　

data 必須是函數

元件就是vue的執行個體，所有vue執行個體中屬性和方法，元件中也可以用，但是data屬性必須是一個函數，因為元件會重複使用在多個地方，為了使用在多個地方的元件資料相對獨立，data屬性需要用一個函數來傳回值。

// 定義元件
Vue.component('simple-counter', {
  template: '<button v-on:click="counter += 1">{{ counter }}</button>',
  data: function () {
        return {
        counter: 0
      }
  }
})

// 使用元件
<div id="example-2">
  <simple-counter></simple-counter>
  <simple-counter></simple-counter>
  <simple-counter></simple-counter>
</div>
......
new Vue({
  el: '#example-2'
})　　

props傳遞資料

如果想給元件中傳遞參數，元件要顯式地用 props 選項聲明它預期的資料：

<!-- 樣式 -->
<style>
    .breadcrumb{width:90%;line-height:50px;
    border-bottom:1px solid #ddd;margin:0px auto;}
    .breadcrumb .hot{font-weight:bold;color:red;letter-spacing:2px;}
</style>

......
<div id="app">
    <bread-crumb pos="首頁>圖檔清單"></bread-crumb>
</div>

<script>
    Vue.component('bread-crumb',{
        props:['pos'],
        template:'<div class="breadcrumb" @click="fnLight">目前位置：<span :class="{hot:isHot}">{{pos}}</span></div>',
        data:function(){
            return {
                isHot:false
            }
        },
        methods:{
            fnLight:function(){
                this.isHot = !this.isHot;
            }
        }
    })
    let vm = new Vue({
        el:'#app'
    })
</script>　　

單檔案元件

将一個元件相關的html結構，css樣式，以及互動的JavaScript代碼從html檔案中剝離出來，合成一個檔案，這種檔案就是單檔案元件，相當于一個元件具有了結構、表現和行為的完整功能，友善元件之間随意組合以及元件的重用，這種檔案的擴充名為“.vue”，比如："menu.vue"。

單檔案元件代碼結構 

// 使用template标簽來定義html部分
<template>
<div class="breadcrumb" @click="fnLight">
  目前位置：<span :class="{hot:isHot}">{{pos}}</span>
</div>
</template>

// javascript要寫成子產品導出的形式：
<script>
export default{
  props:['pos'],
  name:'breadcrumb',
  data:function(){
      return {
          isHot:false
      }
  },
  methods:{
      fnLight:function(){
          this.isHot = !this.isHot;
      }
  }
}
</script>

// 樣式中如果有scope關鍵字，表示這些樣式是元件局部的，不會影響其他元素
<style scoped>
.breadcrumb{
    width:90%;
    line-height:50px;
    border-bottom:1px solid #ddd;
    margin:0px auto;
}
.breadcrumb .hot{
    font-weight:bold;
    color:red;
    letter-spacing:2px;
}
</style>　　

Vue元件開發自動化工具

windows終端操作

1、打開終端

在window開始的搜尋框，輸入cmd，回車；或者在開始上點右鍵，選擇運作，輸入cmd回車；或者在window視窗的位址欄上輸入cmd，回車。

2、常用終端指令

// 檢視檔案夾内容
dir +回車

// 進入某個檔案夾
cd 檔案夾名 +回車

// 進入上一級檔案夾
cd .. +回車 

// 切換到e盤
e: +回車

// 清除螢幕
cls +回車　　

Node.js

Node.js是一個新的後端(背景)語言，它的文法和JavaScript類似，是以可以說它是屬于前端的後端語言，後端語言和前端語言的差別：

  • 運作環境：後端語言一般運作在伺服器端，前端語言運作在用戶端的浏覽器上
  • 功能：後端語言可以操作檔案，可以讀寫資料庫，前端語言不能操作檔案，不能讀寫資料庫。

Node.js如果安裝成功，可以檢視Node.js的版本,在終端輸入如下指令：

node -v　

npm

npm是node.js的包管理器，安裝了node.js同時會自動安裝這個包管理器，可以npm指令來安裝node.js的包。這個工具相當于python的pip管理器。

安裝vue的自動化工具

vue開發生态區提供了用node.js開發的自動化開發工具包，這個工具包可以幫我們編譯單檔案元件。

// 全局安裝 vue-cli
npm install --global vue-cli　

生成Vue單頁面應用項目目錄

單頁應用(SPA)

單頁Web應用（single page web application，SPA），就是将系統所有的操作互動限定在一個web頁面中。單頁應用程式 (SPA) 是加載單個HTML頁面，系統的不同功能通過加載不同功能元件的形式來切換，不同功能元件全部封裝到了js檔案中，這些檔案在應用開始通路時就一起加載完，是以整個系統在切換不同功能時，頁面的位址是不變的，系統切換可以做到局部重新整理，也可以叫做無重新整理，這麼做的目的是為了給使用者提供更加流暢的使用者體驗。

生成項目目錄

使用vue自動化工具可以快速搭建單頁應用項目目錄。該工具為現代化的前端開發工作流提供了開箱即用的建構配置。隻需幾分鐘即可建立并啟動一個帶熱重載、儲存時靜态檢查以及可用于生産環境的建構配置的項目：

// 生成一個基于 webpack 模闆的新項目
$ vue init webpack my-project

// 啟動開發伺服器 ctrl+c 停止服務
cd my-project
npm run dev　

項目目錄結構說明

前端之Vue.js庫的使用

需要關注的是上面标注的三個目錄：

  • 檔案夾1(src)，主開發目錄，要開發的單檔案元件全部在這個目錄下
  • 檔案夾2(static)，靜态資源目錄，所有的css，js檔案放在這個檔案夾
  • 檔案夾3(dist)，項目打包釋出檔案夾，最後要上線單檔案項目檔案都在這個檔案夾中

還有node_modules目錄是node的包目錄，config是配置目錄，build是項目打包時依賴的目錄。

頁面結構說明

前端之Vue.js庫的使用

整個項目是一個主檔案index.html,index.html中會引入src檔案夾中的main.js,main.js中會導入頂級單檔案元件App.vue,App.vue中會通過元件嵌套或者路由來引用components檔案夾中的其他單檔案元件。

元件嵌套

将單檔案元件組合在一起有兩種方式，一種是嵌套方式，一種用路由的方式。嵌套的方式代碼如下：

下圖示中，假設元件A中要嵌入元件B

<template>

    // 在A元件中使用B元件
    <B_zujian></B_zujian>
</template>


<script>
// 先導入B元件，其中'@'表示src目錄，元件後的vue擴充名可以省略
import B_zujian from '@/components/B_zjian'

export default{
    name:'A_zujian',
    data:function(){
        return {
            iNum:0
        }
    },
    // 接着在components屬性選項中注冊
    components:{
        B_zujian
    }
}


</script>　

路由

可以通過路由的方式在一個元件中加載其他元件，要使用路由功能，需要在main.js中先導入路由的包,然後在元件對象中還需要包含它。

import router from './router'

new Vue({
    .....
    router
})

元件中通過路由标簽來加載其他的路由

<!-- 路由标簽 -->
<router-view></router-view>

<!-- 簡寫成下面一個标簽的形式： -->
<router-view/>

路由标簽裡面加載哪個元件呢？在router檔案中的index.js檔案中設定

import Vue from 'vue'
import Router from 'vue-router'

// 導入對應元件 '@' 表示src檔案夾
import MainList from '@/components/MainList'
import UserList from '@/components/UserList'
import UpDate from '@/components/UpDate'

// 使用路由子產品的固定寫法
Vue.use(Router)

// path為'/'表示路由預設加載的元件
// 這些路由預設設定的是App.vue中的路由标簽加載的元件
export default new Router({
  routes: [
    {
      path: '/',
      name: 'MainList',
      component: MainList
    },
    {
      path: '/user',
      name: 'UserList',
      component: UserList
    },
    {
      path: '/update',
      name: 'UpDate',
      component: UpDate
    }
  ]
})

通過連結可以切換路由标簽裡面對應的元件，連結的位址是上面index.js檔案中定義的path值，不過連結标簽是"router-link",連結位址用'to'來定義：

<router-link to="/">股票資訊</router-link>
<router-link to="/user">個人中心</router-link>

連結位址中可以傳遞參數，格式如下：

// name對應的是路由中定義的一個path對應的name屬性
<router-link :to='{name:"UpDate",params:{code:item.code}}'>

有時候需要在元件的js中跳轉頁面，也就是改變路由，改變路由有下面這些方式：

// 目前頁面重新加載
this.$router.go('/user');

// 跳轉到另外一個路由
this.$router.push({path:'/user'});

// 擷取目前的路由位址
var sPath = this.$route.path;　　

資料請求及跨域

資料請求

資料請求使用的是ajax，在vue中使用的axios.js，這個檔案可以在index.html檔案中引入，也可以作為子產品導入，在main.js中導入這個子產品，然後将它綁定在Vue類的原型上。

import axios from 'axios'
Vue.prototype.axios = axios

在元件的js代碼中使用axios：

this.axios({......})　

跨域請求

vue的自動化工具提供了開發的伺服器，我們在這個伺服器環境下開發，改動代碼可以馬上更新顯示，錯誤了還有代碼提示，非常友善，但是，如果我們元件中需要資料，而且資料在另一個伺服器環境下運作，我們就需要跨域請求資料，vue工具中可以使用代理來跨域請求，設定的方法是：在項目的config檔案夾中，打開index.js,在proxyTable一項中設定：

// 'http://localhost:7890' 表示的是要跨域請求的位址
// 如果請求的位址是：'http://localhost:7890/index_data'
// 在請求時就可以寫成: '/apis/index_data'

'/apis': {
    target: 'http://localhost:7890', 
    changeOrigin: true,
    pathRewrite: {
        '^/apis': ''
    }              
}　

打包上線

項目開發完成後，需要把請求資料的代理位址改成和提供資料的伺服器在同一個域的位址，因為最終會把前端代碼放在和資料在同一個域的伺服器下面運作。

// 将下面的請求位址
'/apis/index_data'

// 改成
'/index_data'

改完請求位址後，就可以将代碼打包，生成最終可以上線的單檔案結構：

// 打開終端，ctrl+c停掉開發伺服器，執行下面的指令

npm run build　

自動化程式會将打包的檔案自動生成到項目的dist檔案夾中。

将這些檔案拷貝到提供資料服務的伺服器的靜态目錄檔案夾中，完成最終的上線！

vue js
上一篇: CSS實作表單
下一篇: 一些位運算的技巧整理

繼續閱讀