文档章节

深入理解 ES6

王福林
 王福林
发布于 2017/09/08 16:45
字数 4600
阅读 3
收藏 0
点赞 0
评论 0

深入理解 ES6

本文篇幅较长,有兴趣的可以先收藏再看。本文将重要的 ES6 特性介绍了一遍,并且详细解释了一些重难点。

let && const

let 与 var 的声明用法相同,但是多了一个临时死区(Temporal Distonrtion Zone)的概念。

console.log(a) // -> undefined
var a = 1
console.log(b) // -> Uncaught ReferenceError: b is not defined
let b = 1

可以发现在声明前使用 let 声明的变量会导致报错,这解决了 JS 很多奇怪的问题。并且使用 let 会生成一个块级作用域,作用域外不能访问该变量。

{
let a = 1;
var b = 1;
}
console.log(b); // -> 1
console.log(a); //  -> Uncaught ReferenceError: b is not defined

在 JS 中,声明变量都会提升,不论用什么关键字声明。当使用 let 时变量也会被提升至块级作用域的顶部,但是只提升声明,不提升初始化。并且会产生临时死区,该区域会存放变量,直到执行过声明语句后,方可使用该变量。

在循环中 let 会与前面有些不同,每次迭代都会产生一个新的变量,并用之前的值初始化,如何理解这句话呢,请看以下代码。

for(let i = 0; i < 10; i++) {
    console.log(i) // -> 输入 0 - 9
}
// 上面的循环代码可以这样看
{ // 形成块级作用域
    let i = 0
    {
        let ii = i
        console.log(ii)
    }
    i++
    {
        let ii = i
        console.log(ii)
    }
    i++
    {
        let ii = i
        console.log(ii)
    }
    ...
}

const 与 let 基本类似,只是用 const 声明必须赋值,并且不得修改绑定,什么意思呢,请看代码。

const a = 1;
a = 2 // -> Uncaught TypeError: Assignment to constant variable
// but
const b = {a: 1};
b.a = 2 // 起效

当然了,有办法让这个不能改变

const b = Object.freeze({a: 1})
b.a = 2 // 没有报错,但是 b.a 没有被改变

但是 Object.freeze 只能在这里有效,对于数组这些可以看看这个提案

这两个新的声明方式在全局作用域下不会自动加上 window

字符串相关

部分新增的字符串函数

let string = 'startend'
string.includes('a') // -> true 是否包含
string.endsWith('end') // -> true 是否由 end 结尾
string.startsWith('start') // -> true 是否由 start 开头

模板字面量

很棒的新功能,解决了之前很多麻烦的写法。

// 语法就是 `` 代替之前的引号,在 `` 中使用引号不需要转义
let s = `it's string`

多行字符串

// 这样在语法中就可以换行了
let s = `start \
end`
// 注意在模板字面量中的任何空白符都是起效的
let s = `start \
    end`  // ->  start     end

占位符和标签模板

let s = 'string'
let message = `start${s}`  // -> startstring
// ${} 就是占位符语法,可以更简便的实现字符串插入

// 定义一个 tag 函数,然后直接在 `` 前使用就可以
let m = tag`s${s}e${message}`
// strings 是一个数组,value 是模板字面量中所有的占位符的值
function tag(strings, ...value) {
    // -> ['s', 'e', '']
    console.log(strings)
    // -> ['string', 'startstring']
    console.log(value)
}
// 上面的 ...value 也是 ES6新出的扩展语句,在这里代表不定参数的写法,用于替换 arguments
// 不定参数使用上也是有限制的,必须放在所有参数的末尾,并且在每个函数中只能声明一次
// 扩展语句和 arguments 区别就是代表了 strings 参数后面的所有参数
// 除了上面的写法,还可以用于展开可以迭代(有Symbol.iterator属性)的对象
let array = [1, 2, 3]
console.log(...array)
// 该语法可以解决之前很多地方只能传入单个参数,只能使用 apply 解决的问题
Array.prototype.unshift.apply([4, 5], array) // -> [1, 2, 3, 4, 5]
// 现在可以直接这样写
[4, 5].unshift(...array)
// 展开运算不受不定参数的条件限制,可以一起用

函数

默认参数

ES6 允许给函数增加默认参数

function fn(a = 1, b = 2) {}
// 默认值也可以通过调用函数获得,注意必须调用函数
function fn1(a = 1, b = fn()) {}

新增函数内部方法

在 JS 中,函数有多种用法,可以直接调用,也可以通过 new 构造函数。

在 ES6中,函数内部新增了 [[Call]] 和 [[Construct]] 两个方法。后者会在使用 new 构造函数时执行,其他情况会执行前者方法。

当一个函数必须使用 new 构造时,你可以使用这个新属性 new.target 判断

// new.target 只能在函数中使用
function Fn() {
    if (typeof new.target === 'underfined') { throw ....... }
}

箭头函数

这个特性真的很棒,先介绍下他的几种语法

// 最简单的写法,只有一个参数,单行表达式
value => value
// 多个参数需要使用小括号包裹
(v1, v2) => v2 + v1
// 没有参数需要使用小括号包裹
() => "balabala"
// 多行表达式需要大括号包裹
(v1, v2) => {
    return v1 + v2
}
// 返回一个对象,需要用小括号包裹
() => ({a: 1})
// 立即执行函数,注意普通的立即执行函数的小括号包裹在最外面,箭头函数不需要
((value) => value)("balabala")

箭头函数和普通函数区别还是蛮大的,说几个常用的

  • 没有 this,不能改变 this 绑定
  • 不能通过 new 调用,当然也没有原型
  • 没有 arguments 对象,不能有相同命名参数

箭头函数虽然没有 this ,但是还是可以在内部使用 this 的

  • this 的绑定取决于定义函数时的上下文环境
  • 一旦函数调用,任何改变 this 的方法都无效
// let 有个细节
let x = 11111
let a = {
    x: 1,
    init() {
        // 箭头函数的 this 取决于 init,所以可以打印出 1
        document.addEventListener('click', () => console.log(this.x))
    },
    allowInit: () => {
        // allowInit 直接是个箭头函数,所以这时的 this 变成了 window
        // 但是并不会打印出 11111,忘了 let 的一个细节的可以回到上面看看
        console.log(this.x)) 
    }
    otherInit() {
        // 普通函数的 this 取决于调用函数的位置,this 指向 document
        // 如果想打印出 x,可以使用 bind
        document.addEventListener('click', function() {
            console.log(this.x)
        })
    }
}
a.init() // -> 1
a.allowInit() // -> undefined
a.otherInit() // -> undefined

对象相关

let a = 1
// 当 key 和 value 名字相同时可以简写
let b = { a }
// 对象中的方法也可以简写
let a = {
    init() {}
}
// 对象属性名也可以计算 
let name = 'name'
b[name + '1'] = 2 // === b['name1'] = 2

ES6 也新增了几个对象方法

Object.is(NaN, NaN) // ->true
// 结果基本于 === 相似,除了 NaN 和 +0 -0
Object.is(+0, -0) // -> false
let o = {a: 1}
let a = Object.assign({}, o) // -> {a: 1}
// 第一个参数为目标参数,后面的参数是不定的,参数属性名如果有重复,后面的会覆盖之前的

原型相关

ES6 之前改变对象原型很麻烦

let obj = {a: 1}
let obj1 = {a: 2}
// 已 obj 为原型
let a = Object.create(obj)
// 改变 a 的原型为 obj1
Object.setPrototypeOf(a, obj1) // a.a === 2

访问原型

Object.getPrototypeOf(a) // 访问原型
// ES6 中可以直接通过 super 代表原型
let a = {
    init() {
        return 'Hello'
    }
}
let b = {
    init() {
    // 不能在 super 之前访问 this
        return super.init() + 'World'
    }
}
Object.setPrototypeOf(b, a)
b.init() // -> 'HelloWorld'

但是 super 不是每个函数都可以使用的,只有在函数的简写语法中方可使用。因为在 ES6中新增了一个函数内部属性 [[HomeObject]],这个属性决定了是否可以访问到 super。首先在该属性上调用 Object.getPrototypeOf(绑定的对象),然后找到原型中的同名函数,在设置 this绑定并且调用函数,其实就是一个新增的语法糖。

解构赋值

该特性可以用于对象,数组和传参。

let obj = {a: 1, b: 2}
// 对象解构使用 {},数组解构使用 [],因为这里是对象解构,c 不是 obj 的属性,所以 underfined
// 数组解构中,如果需要解构的变量大于数组索引,多出来的变量也是 undefined
// 解构必须赋值,否则报错。不能 let {a, b, c};
// 赋值不能为 null 或者 undefined,会报错
let {a, b, c} = obj
// 等于 let a = obj.a,可以看做之前介绍的对象属性简写
console.log(a, b, c) // -> 1, 2, underfined
// 如果已经声明了变量并且想使用解构,必须最外面是小括号
({a, b} = obj)
// 如果不想使用 obj 中的对象名,又想使用解构赋值
let {x: a} = obj
// 如果想使用默认值
let {a = 2, c= 3} = obj // -> 1, 3
// 因为 a 是 obj 中的对象,所以默认值被覆盖
// 解构也可以嵌套
let obj = {data: {code: 1}, message: [1, 2]}
// 这个写法在 json 中很好用
// 注意在这个写法中,data 和 message 都是指代了 obj 的属性,并没有被声明变量
let { data: {code}, message: [a] } = obj
console.log(code, a)
// 数组解构和对象解构基本相似,并且简单多了
let message = [1, 2, 3, 4]
// 因为数组取值只能索引取,所以想跳过某几个索引,就用逗号代替
// 同样,数组解构也可以使用默认值和嵌套解构,和对象解构一模一样就不赘述了
let [a, , b] = message // -> 1, 3
// 在上面章节介绍了扩展语法,同样也可以使用在数组解构中
// 可以看到 b 变成了一个数组
let [a, ...b] = message // -> 1, [2, 3, 4]
// 传参使用解构可以让要传的参数更加清晰
function fn(name, {key, value}) {
    console.log(name, key, value)
}
// 使用,注意:传参解构必须起码传入一个值,否则报错
fn(1, {key: 2, value: 3})
// 因为传参解构类似以下写法
function fn(name, {key, value}) {
    let {key, value} = null // 这个上面讲过不能这样写
}

Symbol

ES6 新出的第六个原始类型。多用于避免代码冲突,作为一个私有属性使用,不会被属性遍历出来。可以使用 Object.getOwnPropertySymbols() 检索 Symbol 属性。

创建和使用

// 创建
 let a = Symbol()
 // 更推荐这种写法,可以更加明确这个Symbol的用途
 // 并且有函数可以通过这个字符串取到相应的Symbol
 let b = Symbol('is b')
 // 使用,一般作为可计算属性使用
 let a = {}
 let b = Symbol('is b')
 a[b] = 1
 // 可以在全局注册表中共享同一个 Symbol,但不推荐使用
 // 不存在 is a 会自动创建
 let a = Symbol.for('is a')

暴露内部操作

Symbol 中预定义了一些 well-know Symbol,这些 Symbol 定义了一些语言的内部实现

  • Symbol.hasinstance,用于执行 instanceof 时检测对象的继承信息
  • Symbol.isConcatSpreadable,布尔值,用于判断当使用 concat 函数时是否将数组展开
  • Symbol.iterator,迭代器,后面会讲到
  • Symbol.match,Symbol.replace,Symbol.search,Symbol.split,字符串相关方法的对应内部实现
  • Symbol.toPrimitive,返回对象原始值
  • Symbol.toStringTag,调用 toString

Set 和 Map

Set

Set 是新增的无重复的有序集合,多用于集合去重或者判断集合中是否含有某个元素。

// 创建
let set = new Set()
// 添加元素
set.add(1)
set.add('1')
// 重复的元素不会被添加
set.add(1)
// 判断是否包含元素
set.has(1) // -> true
// 判断长度
set.size() // -> 2
// 删除某个元素
set.delete()
// 移除所有元素
set.clear()

Map

Map 是新增的有序键值对列表,键值可以是任何类型。

// 创建
let map = new Map()
// 设置键值对
map.set('year', "2017")
map.set({}, 'obj')
// 取值
map.get('year') // -> '2017'
// 判断是否有该键值
map.has('year') // -> true
// 获得长度
map.size() // -> 2
// 删除某个键值
map.delete('year')
// 移除所有键值
map.clear()

迭代器和 Generator 函数

迭代器

顾名思义,用来迭代的。之前介绍过 Symbol.iterator,可以迭代的对象都有这个属性,包括数组,Set,Map,字符串和 NodeList。ES6新增的 for-of 就用到了迭代器的功能,但是默认只有上面这些对象能使用。

let a = [1, 2]
for (let value of a) {
    console.log(value) // -> 1, 2
}
// 上面的代码其实就是调用了数组的默认迭代器
let iterator = a[Symbol.iterator]()
// 当调用 next 时会输出这次迭代的 value 和是否迭代完成
console.log(iterator.next()) // {value: 1, done: false}
console.log(iterator.next()) // {value: 2, done: false}
// 已经没元素可以迭代了
console.log(iterator.next()) // {value: undefined, done: true}
// 数组的默认迭代器只会输出 value,如果想同时输出索引的话
// 这里可以使用新特性数组解构 let [index, value]
for (let value of a.entries()) {
    console.log(value) // -> [0, 1]   [1, 2]
}

对于自己创建的对象都是不可迭代的,当然我们也可以让他变成迭代的

let a = {
    array: [],
    // 这是一个 Generator 函数,马上就会讲到
    *[Symbol.iterator]() {
        for(let item in this.array) {
            yield item
        }
    }
}
a.array.push(...[1, 2, 3])
for(let item of a) {
    console.log(item)
}

Generator 函数

用于异步编程。该函数可以暂停和恢复执行,和同步写法很像。

// 星号表示这是一个 Generator 函数
function *gen() {
// 第一次 next 只执行到等号右边
    let first = yield 1
    // 第二次 next 执行 let first = 和 yield 2
    let second = yield 2
    // 不执行接下来的 next 就卡在上一步了
    let thrid = yield 3
}
let g = gen()
g.next() // -> {value: 1, done: false}
g.next() // -> {value: 2, done: false

接下来看下 Generator 函数如何用于异步

function getFirstName() {
    setTimeout(function(){
        gen.next('alex')
    }, 1000);
}

function getSecondName() {
    setTimeout(function(){
        gen.next('perry')
    }, 2000);
}

function *sayHello() {
    var a = yield getFirstName();
    var b = yield getSecondName();
    // settimeout 本来是异步的,通过 Generator 函数写成了同步写法
    console.log(a, b); // ->alex perry
}

var gen = sayHello();

gen.next();

JS 中的类不是其他语言中的类,只是个语法糖,写法如下。

class Person {
// 构造函数
    constructor() {
        this.name = name
    }
    sayName() {
        console.log(this.name)
    }
}
let p = new Person('name')
p.sayName() // -> 'name'

// class 就是以下代码的语法糖
// 对应 constructor
function Person(name) {
    this.name = name
}
// 对应 sayName
Person.prototype.sayName = function() {
    console.log(this.name)
}

类声明相比之前的写法有以下几点优点

  • 类声明和 let 声明一样,有临时死区
  • 类声明中的代码全部运行在严格模式下
  • 必须使用 new 调用

继承

在 ES6 之前写继承很麻烦,既然有个类,那么必然也可以继承类了

class Person {
// 构造函数
    constructor() {
        this.name = name
    }
    sayName() {
        console.log(this.name)
    }
}
// extends 代表继承自Person
class Student extends Person {
    constructor(name, age) {
    // super 的注意事项之前有说过
        super(name)
        // 必须在 super 之后调用 this
        this.age = age
    }
    sayName() {
    // 如果像使用父类的方法就使用这个方法使用
    // 不像使用的话就不写 super,会覆盖掉父类的方法
        super.sayName(this.name)
        console.log(this.age)
    }
}

Promise

概念

用于异步编程。

// 你可以使用 new 创建一个 Promise 对象
let promise = new Promise(function(resolve, reject)) {}
resole() // 代表成功
reject() // 代表失败
promise.then(onFulfilled, onRejected) // 当调用 resole 或者 reject ,then 可以监听到
promise.catch() // reject 或者 throw时可以监听到

Promise 有三个状态

  • pending,等待状态,也就是既不是 resolve 也不是 reject 状态
  • fulfilled,resolve 以后进入这个状态
  • reject,reject 以后进入这个状态

一般使用情况

function delay() {
// 创建一个 promise
    return new Promise((resolve, reject) => {
    // 当调用 promise 时,里面的内容会立即执行
        console.log('in delay')
        setTimeout(() => {
          resolve(1)
        }, 1000)
    });
}
function otherDelay() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
          reject(1)
        }, 1000)
    });
}
// 这里会先输出 delay 函数中的 log,然后再输出 outer,接下来1秒以后输出3个1
delay()
// then 可以捕获 resolve 和 reject
    .then((value) => {
        console.log(value)
    })
console.log('outer')

otherDelay()
// 捕获 reject时,如果不需要捕获 resolve 时可以这样写
    .then(null, (value) => {
        console.log(value)
    })
// 捕获 reject 或者 throw 时推荐使用这个写法,原因后面会说
otherDelay()
    .catch((value) => {
        console.log(value);
    })

以上是最常用的 Promise 写法,现在介绍 Promise 链

delay()
// then 会返回一个新的 promise 对象
    .then((value) => {
     // 这样就可以传参了
        return value + 1
    }).then((value) => {
        console.log(value) // -> 2
        // then 里面可以也可以传入一个函数名,会自动调用
        // 如果传入的函数有参数会自动传入
    }).then(delay).then((value) => {
        console.log(value) // -> 1
        // 如果在then 中抛出错误,只有 catch 才能监听到,所以推荐使用 catch 监听错误
        throw new Error('error')
    }).then((value) => {
        console.log(value) // 这个then 不会执行
    }).catch((error) => {
        console.log('catch' + error) // -> catch Error
    })

Promise 高级用法

开发中可能会有需求,需要一次上传几张图片,全部上传成功以后有个提示,这时候就可以用到 Promise.all()

function updateOne() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('one')    
        }, 1000)
    });
}
function updateTwo() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('two')    
        }, 2000)
    });
}
// all 函数接收一个可迭代对象,注意这里传入函数必须调用
let promise = Promise.all([updateOne(), updateTwo()])
// 只有当 all 中的异步全部完成了才会调用 then
promise
    .then((value) => {
    // value 是个函数,顺序按照 all 里的迭代对象的顺序
        console.log(value) // -> ["one", "two"]
    })

如果一个异步任务超时了,你想直接取消,可以通过 Promise.race()

// 假设该任务执行时间超过1秒就算超时,应该 cancel
function delay() {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
            resolve('finish')
        }, 1500);
    });
}
function cancel() {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
            resolve('cancel')
        }, 1000);
    });
}
// 接收的参数和 all 相同
let promise = Promise.race([delay(), cancel()])
// race 中只要有一个任务完成,then 就会被调用,这样就可以 cancel 掉所有超时任务
promise
    .then((value) => {
        console.log(value) // -> cancel
    })

Proxy

Proxy 可以创建一个代替目标对象的代理,拦截语言内部的操作。

let handle = {}
let target = {}
// 这样就创建了target 对象的代理,但是这个代理其实没有任何用处
let p = new Proxy(target, handle)

上面的代码中可以看到传入了一个 handle 的对象,只有当这个对象中包含一些代理行为的函数时,这个代理才有用。具有的代理行为函数可以去 MDN查看,这里举例几个用法。

let handle = {
    // 改变 set 的内部操作
        set(target, key, value) {
        // 当给 age 属性赋值小于19时报错
            console.log(value)
            if (key === 'age') {
                if (value < 19) {
                    throw new Error('未成年')
                }
            }
        }
    }
let target = {}
let p = new Proxy(target, handle)
p.age = 1 // -> 报错
p.age = 19 // -> 没问题

模块化

ES6 引入了原生的模块化,这样就可以抛弃之前的 AMD 或者 CMD 规范了,如果对模块化还没什么了解,可以看下我之前的文章 明白 JS 模块化

// example.js 文件下
// export 可以导出任何变量,函数或者类
export var age = 14
export function sum(n1, n2) {
    return n1 + n2
}
export class Person {
    constructor(age) {
        this.age = age
    }
}
// 别的 JS 文件中导入
// 如果想导入整个模块并且自己命名,就可以这样使用
// import 后面代表模块名,from 后面代表要导入的文件地址
import * as Example from './example'
console.log(Example.age) // -> 14
// 当然你也可以只使用模块中的一个功能
// 这里使用了对象解构的方法拿到需要的功能,注意这里名字必须相同,否则使用会报错
import { age, sum } from './example'
console.log(age) // -> 14
console.log(sum(1, 2)) // -> 3
// 现在我只想导出一个功能,并且外部可以随便命名该如何做呢?
// default 一个文件中只能使用一次
export default var age = 14
// MyAge 可以随便自己喜欢命名
import MyAge from './example'
console.log(MyAge) // -> 14

本文转载自:https://juejin.im/post/59a80ba06fb9a02497170704

共有 人打赏支持
王福林
粉丝 9
博文 93
码字总数 36521
作品 0
徐汇
程序员
ES6-7

JavaScript Promise 迷你书(中文版) 超详细介绍promise的gitbook,看完再不会promise...... 本书的目的是以目前还在制定中的ECMAScript 6 Promises规范为中心,着重向各位读者介绍JavaScr...

掘金官方 ⋅ 01/05 ⋅ 0

JavaScript 异步

JavaScript怎么使用循环代替(异步)递归 问题描述 在开发过程中,遇到一个需求:在系统初始化时通过http获取一个第三方服务器端的列表,第三方服务器提供了一个接口,可通过分页形式获取列表。...

掘金官方 ⋅ 01/02 ⋅ 0

第一次经历金三银四,前端面试总结

距离上次面试已经是21个月了,又要面试了,不免忐忐忑忑 小伙伴支招,最起码要投两轮简历吧: 第一轮,投不是最意向的,大公司小公司都投一下试试,了解一下市场对一年多工作经验的前端有什么...

瓦斯程序媛 ⋅ 05/16 ⋅ 0

深入理解 ES6

本文篇幅较长,有兴趣的可以先收藏再看。本文将重要的 ES6 特性介绍了一遍,并且详细解释了一些重难点。 let && const 与 的声明用法相同,但是多了一个临时死区(Temporal Distonrtion Zone...

夕阳 ⋅ 2017/09/08 ⋅ 0

13篇文章,教你学会ES6知识点

ES6 深入理解ES6》学习笔记 本文用于汇总链接到各个子章节的内容,github 欢迎大家题issues和PR,如果对你有帮助,也可以给 star 支持 :) 目录 第一章 块级绑定 第二章 字符串和正则表达式 ...

你听___ ⋅ 05/08 ⋅ 0

JavaScript杂谈

浏览器内的事件队列 众所周知JavaScript是基于单线程运行的,同时又是可以异步执行的,一般来说这种既是单线程又是异步的语言都是基于事件来驱动的,恰好浏览器就给JavaScript提供了这么一个...

掘金官方 ⋅ 2017/12/06 ⋅ 0

深入理解JavaScript

JavaScript深入之继承的多种方式和优缺点 JavaScript深入系列第十五篇,讲解JavaScript各种继承方式和优缺点。 写在前面 本文讲解JavaScript各种继承方式和优缺点。 但是注意: 这篇文章更像...

掘金官方 ⋅ 01/11 ⋅ 0

3行代码实现一个简易版promise

前言 作为一个后端过来的同学,刚入门前端的时候,被js种种「反人类」的概念折腾的死去活来的. 其中一个印象比较深刻的,就是promise,感觉实在太难理解了...所有就有了写个简单的promise的想法....

Noahlam ⋅ 05/28 ⋅ 0

《探索ES6》书评与作者采访

由Axel Rauschmayer编著的《探索ES6》是对JavaScript最新特性的一次深入探讨,本文包含了对作者所进行的一次简短的访谈内容。 Axel Rauschmayer博士的著作《探索ES6:升级至JavaScript的下一...

一配 ⋅ 2015/12/03 ⋅ 0

【探秘ES6】系列专栏(二):迭代器和for-of循环

ES6作为新一代JavaScript标准,即将与广大前端开发者见面。为了让大家对ES6的诸多新特性有更深入的了解,Mozilla Web开发者博客推出了《ES6 In Depth》系列文章。CSDN已获授权,将持续对该系...

一配 ⋅ 2015/10/22 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

来自一个优秀Java工程师的简历

写在前面: 鉴于前几天的一份前端简历,虽然带着很多不看好的声音,但却帮助了很多正在求职路上的人,不管评论怎么说,我还是决定要贴出一份后端的简历。 XXX ID:357912485 目前正在找工作 ...

颖伙虫 ⋅ 14分钟前 ⋅ 0

Confluence 6 恢复一个站点有关使用站点导出为备份的说明

推荐使用生产备份策略。我们推荐你针对你的生产环境中使用的 Confluence 参考 Production Backup Strategy 页面中的内容进行备份和恢复(这个需要你备份你的数据库和 home 目录)。XML 导出备...

honeymose ⋅ 今天 ⋅ 0

JavaScript零基础入门——(九)JavaScript的函数

JavaScript零基础入门——(九)JavaScript的函数 欢迎回到我们的JavaScript零基础入门,上一节课我们了解了有关JS中数组的相关知识点,不知道大家有没有自己去敲一敲,消化一下?这一节课,...

JandenMa ⋅ 今天 ⋅ 0

火狐浏览器各版本下载及插件httprequest

各版本下载地址:http://ftp.mozilla.org/pub/mozilla.org//firefox/releases/ httprequest插件截至57版本可用

xiaoge2016 ⋅ 今天 ⋅ 0

Docker系列教程28-实战:使用Docker Compose运行ELK

原文:http://www.itmuch.com/docker/28-docker-compose-in-action-elk/,转载请说明出处。 ElasticSearch【存储】 Logtash【日志聚合器】 Kibana【界面】 答案: version: '2'services: ...

周立_ITMuch ⋅ 今天 ⋅ 0

使用快嘉sdkg极速搭建接口模拟系统

在具体项目研发过程中,一旦前后端双方约定好接口,前端和app同事就会希望后台同事可以尽快提供可供对接的接口方便调试,而对后台同事来说定好接口还仅是个开始、设计流程,实现业务逻辑,编...

fastjrun ⋅ 今天 ⋅ 0

PXE/KickStart 无人值守安装

导言 作为中小公司的运维,经常会遇到一些机械式的重复工作,例如:有时公司同时上线几十甚至上百台服务器,而且需要我们在短时间内完成系统安装。 常规的办法有什么? 光盘安装系统 ===> 一...

kangvcar ⋅ 昨天 ⋅ 0

使用Puppeteer撸一个爬虫

Puppeteer是什么 puppeteer是谷歌chrome团队官方开发的一个无界面(Headless)chrome工具。Chrome Headless将成为web应用自动化测试的行业标杆。所以我们很有必要来了解一下它。所谓的无头浏...

小草先森 ⋅ 昨天 ⋅ 0

Java Done Right

* 表示难度较大或理论性较强。 ** 表示难度更大或理论性更强。 【Java语言本身】 基础语法,面向对象,顺序编程,并发编程,网络编程,泛型,注解,lambda(Java8),module(Java9),var(...

风华神使 ⋅ 昨天 ⋅ 0

Linux系统日志

linux 系统日志 /var/log/messages /etc/logrotate.conf 日志切割配置文件 https://my.oschina.net/u/2000675/blog/908189 logrotate 使用详解 dmesg 命令 /var/log/dmesg 日志 last命令,调......

Linux学习笔记 ⋅ 昨天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部