2. 程式人生 > >es6開發：總結歸納es6的十大特性

es6開發：總結歸納es6的十大特性

阿新 • • 發佈：2019-02-03

ES6 簡介

ECMAScript 6 簡稱 ES6，是 JavaScript 語言的下一代標準，已經在2015年6月正式釋出了。它的目標是使得 javascript 語言可以用來編寫複雜的大型應用程式，成為企業級開發語言。

ECMAScript 和 JavaScript 的關係：前者是後者的語法規格，後者是前者的一種實現

image

新特性

let、const

let 定義的變數不會被變數提升，const 定義的常量不能被修改，let 和 const 都是塊級作用域

ES6前，js 是沒有塊級作用域 {} 的概念的。（有函式作用域、全域性作用域、eval作用域）

ES6後，let 和 const 的出現，js 也有了塊級作用域的概念，前端的知識是日新月異的~

變數提升：在ES6以前，var關鍵字宣告變數。無論宣告在何處，都會被視為宣告在函式的最頂部；不在函式內即在全域性作用域的最頂部。這樣就會引起一些誤解。例如：

console.log(a);  // undefined
var a = 'hello';

# 上面的程式碼相當於
var a;
console.log(a);
a = 'hello';

# 而 let 就不會被變數提升
console.log(a); // a is not defined
let a = 'hello';
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

const 定義的常量不能被修改

var name = "bai"
 
;
name = "ming";
console.log(name); // ming


const name = "bai";
name = "ming"; // Assignment to constant variable.
console.log(name);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

import、export

import匯入模組、export匯出模組

// 全部匯入
import people from './example'

// 將整個模組當作單一物件進行匯入，該模組的所有匯出都會作為物件的屬性存在
import * as example from "./example.js"
console.log(example.name)
console.log(example.getName())

// 匯入部分，引入非 default 時，使用花括號
 

import {name, age} from './example'


// 匯出預設, 有且只有一個預設
export default App

// 部分匯出
export class App extend Component {};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

class、extends、super

ES5中最令人頭疼的的幾個部分：原型、建構函式，繼承，有了ES6我們不再煩惱！

ES6引入了Class（類）這個概念。

class Animal {
    constructor() {
        this.type = 'animal';
    }
    says(say) {
        console.log(this.type + ' says ' + say);
    }
}

let animal = new Animal();
animal.says('hello'); //animal says hello

class Cat extends Animal {
    constructor() {
        super();
        this.type = 'cat';
    }
}

let cat = new Cat();
cat.says('hello'); //cat says hello
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

上面程式碼首先用class定義了一個“類”，可以看到裡面有一個constructor方法，這就是構造方法，而this關鍵字則代表例項物件。簡單地說，constructor內定義的方法和屬性是例項物件自己的，而constructor外定義的方法和屬性則是所有實力物件可以共享的。

Class之間可以通過extends關鍵字實現繼承，這比ES5的通過修改原型鏈實現繼承，要清晰和方便很多。上面定義了一個Cat類，該類通過extends關鍵字，繼承了Animal類的所有屬性和方法。

super關鍵字，它指代父類的例項（即父類的this物件）。子類必須在constructor方法中呼叫super方法，否則新建例項時會報錯。這是因為子類沒有自己的this物件，而是繼承父類的this物件，然後對其進行加工。如果不呼叫super方法，子類就得不到this物件。

ES6的繼承機制，實質是先創造父類的例項物件this（所以必須先呼叫super方法），然後再用子類的建構函式修改this。

// ES5
var Shape = function(id, x, y) {
    this.id = id,
        this.move(x, y);
};
Shape.prototype.move = function(x, y) {
    this.x = x;
    this.y = y;
};

var Rectangle = function id(ix, x, y, width, height) {
    Shape.call(this, id, x, y);
    this.width = width;
    this.height = height;
};
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var Circle = function(id, x, y, radius) {
    Shape.call(this, id, x, y);
    this.radius = radius;
};
Circle.prototype = Object.create(Shape.prototype);
Circle.prototype.constructor = Circle;

// ES6
class Shape {
    constructor(id, x, y) {
        this.id = id this.move(x, y);
    }
    move(x, y) {
        this.x = x this.y = y;
    }
}

class Rectangle extends Shape {
    constructor(id, x, y, width, height) {
        super(id, x, y) this.width = width this.height = height;
    }
}

class Circle extends Shape {
    constructor(id, x, y, radius) {
        super(id, x, y) this.radius = radius;
    }
}
  • 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
  • 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

arrow functions （箭頭函式）

函式的快捷寫法。不需要 function 關鍵字來建立函式，省略 return 關鍵字，繼承當前上下文的 this 關鍵字

// ES5
var arr1 = [1, 2, 3];
var newArr1 = arr1.map(function(x) {
  return x + 1;
});

// ES6
let arr2 = [1, 2, 3];
let newArr2 = arr2.map((x) => {
  x + 1
});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

箭頭函式小細節：當你的函式有且僅有一個引數的時候，是可以省略掉括號的；當你函式中有且僅有一個表示式的時候可以省略{}

let arr2 = [1, 2, 3];
let newArr2 = arr2.map(x => x + 1);
  • 1
  • 2
  • 1
  • 2

JavaScript語言的this物件一直是一個令人頭痛的問題，執行上面的程式碼會報錯，這是因為setTimeout中的this指向的是全域性物件。

class Animal {
    constructor() {
        this.type = 'animal';
    }
    says(say) {
        setTimeout(function() {
            console.log(this.type + ' says ' + say);
        }, 1000);
    }
}

var animal = new Animal();
animal.says('hi'); //undefined says hi
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

解決辦法：

// 傳統方法1: 將this傳給self,再用self來指代this
says(say) {
    var self = this;
    setTimeout(function() {
        console.log(self.type + ' says ' + say);
    }, 1000);
}

// 傳統方法2: 用bind(this),即
says(say) {
    setTimeout(function() {
        console.log(this.type + ' says ' + say);
    }.bind(this), 1000);
}

// ES6: 箭頭函式
// 當我們使用箭頭函式時，函式體內的this物件，就是定義時所在的物件
says(say) {
    setTimeout(() => {
        console.log(this.type + ' says ' + say);
    }, 1000);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

template string （模板字串）

解決了 ES5 在字串功能上的痛點。

第一個用途：字串拼接。將表示式嵌入字串中進行拼接，用 ` 和${}`來界定。

// es5
var name1 = "bai";
console.log('hello' + name1);

// es6
const name2 = "ming";
console.log(`hello${name2}`);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

第二個用途：在ES5時我們通過反斜槓來做多行字串拼接。ES6反引號 “ 直接搞定。

// es5
var msg = "Hi \
man!";

// es6
const template = `<div>
    <span>hello world</span>
</div>`;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

另外：includes repeat

// includes：判斷是否包含然後直接返回布林值
let str = 'hahah';
console.log(str.includes('y')); // false

// repeat: 獲取字串重複n次
let s = 'he';
console.log(s.repeat(3)); // 'hehehe'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

destructuring （解構）

簡化陣列和物件中資訊的提取。

ES6前，我們一個一個獲取物件資訊；

ES6後，解構能讓我們從物件或者數組裡取出資料存為變數

// ES5
var people1 = {
  name: 'bai',
  age: 20,
  color: ['red', 'blue']
};

var myName = people1.name;
var myAge = people1.age;
var myColor = people1.color[0];
console.log(myName + '----' + myAge + '----' + myColor);

// ES6
let people2 = {
  name: 'ming',
  age: 20,
  color: ['red', 'blue']
}

let { name, age } = people2;
let [first, second] = people2.color;
console.log(`${name}----${age}----${first}`);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

default 函式預設引數

// ES5 給函式定義引數預設值
function foo(num) {
  num = num || 200;
  return num;
}

// ES6
function foo(num = 200) {
  return num;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

rest arguments （rest引數）

解決了 es5 複雜的 arguments 問題

function foo(x, y, ...rest) {
    return ((x + y) * rest.length);
}
foo(1, 2, 'hello', true, 7); // 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

Spread Operator （展開運算子）

第一個用途：組裝陣列

let color = ['red', 'yellow'];
let colorful = [...color, 'green', 'blue'];
console.log(colorful); // ["red", "yellow", "green", "blue"]
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

第二個用途：獲取陣列除了某幾項的其他項

let num = [1, 3, 5, 7, 9];
let [first, second, ...rest] = num;
console.log(rest); // [5, 7, 9]
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

物件

物件初始化簡寫

// ES5
function people(name, age) {
  return {
    name: name,
    age: age
  };
}

// ES6
function people(name, age) {
  return {
    name,
    age
  };
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

物件字面量簡寫（省略冒號與 function 關鍵字）

// ES5
var people1 = {
  name: 'bai',
  getName: function () {
    console.log(this.name);
  }
};

// ES6
let people2 = {
  name: 'bai',
  getName () {
    console.log(this.name);
  }
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

另外：Object.assign()

ES6 物件提供了Object.assign()這個方法來實現淺複製。Object.assign()可以把任意多個源物件自身可列舉的屬性拷貝給目標物件，然後返回目標物件。第一引數即為目標物件。在實際專案中，我們為了不改變源物件。一般會把目標物件傳為{}

const obj = Object.assign({}, objA, objB)

// 給物件新增屬性
this.seller = Object.assign({}, this.seller, response.data)
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

Promise

用同步的方式去寫非同步程式碼

// 發起非同步請求
fetch('/api/todos')
  .then(res => res.json())
  .then(data => ({
    data
  }))
  .catch(err => ({
    err
  }));
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

Generators

生成器（ generator）是能返回一個迭代器的函式。

生成器函式也是一種函式，最直觀的表現就是比普通的function多了個星號*，在其函式體內可以使用yield關鍵字,有意思的是函式會在每個yield後暫停。

這裡生活中有一個比較形象的例子。咱們到銀行辦理業務時候都得向大廳的機器取一張排隊號。你拿到你的排隊號，機器並不會自動為你再出下一張票。也就是說取票機“暫停”住了，直到下一個人再次喚起才會繼續吐票。

迭代器：當你呼叫一個generator時，它將返回一個迭代器物件。這個迭代器物件擁有一個叫做next的方法來幫助你重啟generator函式並得到下一個值。next方法不僅返回值，它返回的物件具有兩個屬性：done和value。value是你獲得的值，done用來表明你的generator是否已經停止提供值。繼續用剛剛取票的例子，每張排隊號就是這裡的value，列印票的紙是否用完就這是這裡的done。

// 生成器
function *createIterator() {
  yield 1;
  yield 2;
  yield 3;
}

// 生成器能像正規函式那樣被呼叫，但會返回一個迭代器
let iterator = createIterator();

console.log(iterator.next().value); // 1
console.log(iterator.next().value); // 2
console.log(iterator.next().value); // 3
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

迭代器對非同步程式設計作用很大，非同步呼叫對於我們來說是很困難的事，我們的函式並不會等待非同步呼叫完再執行，你可能會想到用回撥函式，（當然還有其他方案比如Promise比如Async/await）。

生成器可以讓我們的程式碼進行等待。就不用巢狀的回撥函式。使用generator可以確保當非同步呼叫在我們的generator函式執行一下行程式碼之前完成時暫停函式的執行。

那麼問題來了，咱們也不能手動一直呼叫next()方法，你需要一個能夠呼叫生成器並啟動迭代器的方法。就像這樣子的：

function run(taskDef) {
  // taskDef 即一個生成器函式
  // 建立迭代器，讓它在別處可用
  let task = taskDef();

  // 啟動任務
  let result = task.next();

  // 遞迴使用函式來保持對 next() 的呼叫
  function step() {
    // 如果還有更多要做的
    if (!result.done) {
      result = task.next();
      step();
    }
  }

  // 開始處理過程
  step();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

總結

以上就是 ES6 最常用的一些語法，可以說這20%的語法，在ES6的日常使用中佔了80%

相關推薦

es6開發：總結歸納es6的十大特性

ES6 簡介 ECMAScript 6 簡稱 ES6，是 JavaScript 語言的下一代標準，已經在2015年6月正式釋出了。它的目標是使得 javascript 語言可以用來編寫複雜的大型應用程式，成為企業級開發語言。 ECMAScript 和 JavaScri

es6的十大特性

https://blog.csdn.net/persistencegoing/article/details/84376427   ES6（ECMAScript2015）的出現，無疑給前端開發人員帶來了新的驚喜，它包含了一些很棒的新特性，可以更加方便的實現很多複雜的操作，提高開發人

javascript開發：ES5與ES6的“this”深入分析

ES6中新增了箭頭函式這種語法,箭頭函式以其簡潔性和方便獲取this的特性,俘獲了大批粉絲兒 它也可能是面試中的寵兒, 我們關鍵要搞清楚 箭頭函式和普通函式中的this 一針見血式總結: 普通函式中的this: 1. this總是代表它的直接呼叫者, 例如 obj

前端開發者不得不知的ES6十大特性

ES6（ECMAScript2015）的出現，無疑給前端開發人員帶來了新的驚喜，它包含了一些很棒的新特性，可以更加方便的實現很多複雜的操作，提高開發人員的效率。 本文主要針對ES6做一個簡要介紹。 主要譯自：  http://webapplog.com/ES6/comm

多線程面試題系列（16）：多線程十大經典案例之一 雙線程讀寫隊列數據

als single 間隔 eas 講解 art ces 依賴 ini 前十五篇中介紹多線程的相關概念，多線程同步互斥問題（第四篇）及解決多線程同步互斥的常用方法——關鍵段、事件、互斥量、信號量、讀寫鎖。為了讓大家更加熟練運用多線程，將會有十篇文章來講解十個多線程使用案例，

看過來~中國消協權威全新解讀：揭祕電商法十大亮點！

電商法揭祕電商法十大亮點！ 2018年8月31日，備受關注的《電子商務法》經第十三屆全國人大常委會第五次會議表決通過，並將於2019年1月1日起正式施行。在這部法律制定過程中，中國消費者協會和各地消費者協會（委員會，以下簡稱消協）廣泛聽取消費者意見，積極反映消費者訴求，認真開展研究工作，提出大量

Gartner總結2014年十大科技趨勢

全球首家資訊科技研究和分析機構Gartner總結出以下2014年十大戰略技術趨勢： 第一、移動裝置的多樣性和管理 Gartner 暗示從現在起直到2018年，自發形成的“自帶裝置”辦公（ BYOD）引發種類繁多的移動裝置層出不窮，不同的使用者環境和互動模式將導致“任一

軟體開發獲取客戶需求的十大溝通技巧

    成功的軟體產品是建立在成功的需求基礎之上的，而高質量的需求來源於使用者與開發人員之間有效的溝通與合作。當用戶有一個問題可以用計算機系統來解決，而開發人員開始幫助使用者解決這個問題，溝通就開始了，溝通技巧就顯得尤為重要了。 　　需求獲取可能是軟體開發中最困難、最關

後端程式設計師必備：索引失效的十大雜症

背景 最近生產爆出一條慢sql，原因是用了or和!=，導致索引失效。於是，總結了索引失效的十大雜症，希望對大家有幫助，加油。 一、查詢條件包含or，可能導致索引失效 新建一個user表，它有一個普通索引userId，結構如下： CREATE TABLE `user` ( `id` int(11) NOT

springboot SpringApplication 的十大特性

sna nco exit failed nconf 橫幅 ica 程序 arguments 1、啟動失敗 如果你啟動項目失敗，你通過註冊FailureAnalyzers 來獲取錯誤信息和解決辦法。比如你啟動應用的8080端口被占用了，你將看到如下信息： *********

jdk8十大特性並代碼demo（轉）

lB 優化 nco 限制 頂部 格式 默認方法 foreach meta 一、十大特性 1.Lambda表達式 2.Stream函數式操作流元素集合 3.接口新增：默認方法與靜態方法 4.方法引用,與Lambda表達式聯合使用 5.引入重復註解 6.類型註解

JAVA 8 十大特性

1. Lambda表示式 Lambda表示式可以說是Java 8最大的賣點，她將函數語言程式設計引入了Java。Lambda允許把函式作為一個方法的引數，或者把程式碼看成資料。 一個Lambda表示式可以由用逗號分隔的引數列表、–>符號與函式體三部分表示。

八、IntelliJ IDEA 2017 的十大特性(3)

IntelliJ IDEA 攜帶強大功能的同時，其本身的特性也非常多，自然學習成本相比於同類的其他 IDE 工具就更高一些。為了幫助讀者快速熟悉 IntelliJ IDEA，從而提高讀者利用 IDEA 的進行開發的效率。本文將簡單地介紹 IntelliJ IDEA 最重要的1

【轉】Java8十大特性詳解

“Java is still not dead—and people are starting to figure that out.” 本教程將用帶註釋的簡單程式碼來描述新特性，你將看不到大片嚇人的文字。 一、介面的預設方法Java 8允許我們給介面新增一個非抽象的方法實現，只需要使用 default關鍵

java8十大特性

Java 8筆記1、Lambda表示式1.1、什麼叫Lambda表示式：Lambda表示式就是一段帶有引數的可執行語句塊1.2、Lambda表示式在java語言中引入了一個新的語法元素和操作符；這個操作符為“->”,該操作符被稱為Lambda或箭頭操作符;它將Lambd

第一節：es6開發環境的搭建

index 項目結構 json dev 技術 reset ID .com 分享 第一章：es6開發環境的搭建 　　命令：npm init -y 生成package.json文件（依賴文件）；項目結構如下： 全局安裝 babel-cli 命令如下：npm instal

通過Hadoop安全部署經驗總結，開發出以下十大建議，以確保大型和復雜多樣環境下的數據信息安全。

同時 數據集 環境 部署 集群 暴露 用戶 控制 特定 通過Hadoop安全部署經驗總結，開發出以下十大建議，以確保大型和復雜多樣環境下的數據信息安全。 1、先下手為強!在規劃部署階段就確定數據的隱私保護策略，最好是在將數據放入到Hadoop之前就確定好保護策略。　　2、確

乾貨分享：十年大廠資深程式設計師的開發經驗總結

本文由騰訊雲加社群整理和釋出，原文連結：cloud.tencent.com/developer/article/1004735，內容有刪減和改動。 1、引言 在網際網路一線做了十年的程式開發，經歷了網易、百度、騰訊研究院、MIG 等幾個地方，陸續做過 3D 遊戲、2D 頁遊、瀏覽器、移動端翻

面試總結：html5的新特性（十大類）

 這裡只以 根目錄的方式來說明，詳細的見如下連線 1.語義化標籤 好處:1.使程式碼結構清晰，便於閱讀2.便於SEO3.無障礙閱讀4.便於後期的維護與開發 2.智慧表單 html5中提供了多個新的型別的input型別 1.color2.datatime3.dat

數據挖掘十大算法總結--核心思想，算法優缺點，應用領域

data- 文本分類 target apr 排名 ans kmean 全部 等等 --------------------------