Handwritten Vue2.0 data hijacking example

npm install webpack webpack-cli webpack-dev-server -D

const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
module.exports = {
 entry: './src/index.js',
 output: {
  filename: 'bundle.js',
  path: path.resolve(__dirname, 'dist')
 },
 resolve: { 
  modules:
  path.resolve(__dirname, ''), path.resolve(__dirname, 'node_modules')  
  ] 
 },
 plugins: [  
  new HtmlWebpackPlugin({   
   template: path.resolve(__dirname, 'public/index.html')  
  }) 
 ]
}

import {initState} from './init.js';

function Vue (options) {
 this._init(options); // Data initialization}
Vue.prototype._init = function (options) {
 var vm = options; // Save the instance vm.$options = options; // Instance mount initState(vm); // Instance initialization }

function initState (vm) {
 var options = vm.$options; // Get options
 if (options.data) {
  initData(vm); // Because computed and watch need to be initialized here, initialize data};

function initData (vm) {
 var data = vm.$options.data; // Reassign data, do not change user-defined data
 data = vm._data = typeof data === 'function' ? data.call(vm) : data || {};
 for (var key in data) {
  proxyData(vm, '_data', key); // Reassign the value of data};
 observe(vm._data); //Observe the internal data}

function proxyData(vm, target, key) { 
 Object.defineProperty(vm, key, {  
   get () {   
   // Interception is done here: vm.xxx => vm._data.xxx   
   return vm[target][key];  
  },  
  set(newValue) {   
   // vm.xxx = yyy ===> vm._data.title = yyy   
   vm[target][key] = newValue;  
  } 
 }) 
}
export default proxyData;

function observe(data) {
 if (typeof data !== 'object' || data = null) return;
 return new Observer(data); // If it is an application type, add an observer directly} 

function Observer(data) {
 if (Array.isArray(data)) {
  // Processing array data._proto_ = arrMethods; 
 }
 else {
  //Processing object this.walks(data);
 }
}
Observer.prototype.walks = function (data) {
 let keys = Object.keys(data); // Get all the keys under data, and it is still an array for (var i = 0 ; i < keys.length ; i++) {  
  var key = keys[i];  
  var value = data[key];  
  defineReactiveData(data, key, value); // Each regenerates responsive data }}

function defineReactiveData (data, key, value) { 
 observe(value); // Then recursively apply to the child elements. 
 Object.defineProperty(data, key, {  
  get() {   
   return value;  
  },  
  set (newValue) {   
   if (newValue === value) return;   
   value = newValue; // trigger change } 
 }
 )
};

import {ARR_METHODS} from './config.js';  
 // A collection of 7 array methods import observeArr from './observeArr.js';
var originArrMethods = Array.prototype, 
arrMethods = Object.create(originArrMethods); 
ARR_METHODS.map(function (m) { 
 arrMethods[m] = function () {  
  var args = Array.prototype.slice.call(arguments); // Convert class array to array var rt = originArrMethods[m].apply(this, args);  
  var newArr;  
  switch (m) {   
   case 'push':   
   case 'ushift':     
    newArr = args;   
   case 'splice':    
    newArr = args.slice(2);    
    break;   
   default:     
    break; };  
  newArr && observeArr(newArr);  
  return rt; 
  } 
}); 
 export { arrMethods }

import observe from "./observe";
function observeArr (arr) { 
 for (var i = 0 ; i < arr.length ; i++) {  
  observe(arr[i]); // Go back to observe. 
 }
}
export default observeArr;