1.确认_config.yml 中有 post_asset_folder。

Hexo 提供了一种更方便管理 Asset 的设定：post_asset_folder,当设置post_asset_folder为true参数后，新建文件时Hexo会自动建立一个与文章同名的文件夹
可以把与该文章相关的所有资源都放到那个文件夹，如此一来，您便可以更方便的使用资源。

2.安装一个可以上传本地图片的插件

1
2
3

//在hexo的目录下执行

$ npm install https://github.com/CodeFalling/hexo-asset-image --save

3.完成安装后用hexo新建文章的时候会发现_posts目录下面会多出一个和文章名字一样的文件夹。图片就可以放在文件夹下面。如下图：

1

$ hexo new GitFlow

查看更多文章

Git flow (git工作流)

01 - 首先，项目存在两个长期分支。

• 主分支master

  • Git主分支的名字，默认叫做Master。它是自动建立的，版本库初始化以后，默认就是在主分支在进行开发。

• 开发分支develop

  • 我们把开发用的分支，叫做Develop，这个分支可以用来生成代码的最新隔夜版本（nightly）。如果想正式对外发布，就在Master分支上，对Develop分支进行”合并”（merge）

    1 2 3 4 5

    //切换到Master分支 　　git checkout master //对Develop分支进行合并 　　git merge --no-ff develop

前者用于存放对外发布的版本，任何时候在这个分支拿到的，都是稳定的分布版；后者用于日常开发，存放最新的开发版。

02 - 其次，项目存在三种短期分支

• 功能分支（feature branch）
  • 它是为了开发某种特定功能，从Develop分支上面分出来的。开发完成后，要再并入Develop。
  • 功能分支的名字，可以采用feature-*的形式命名。

    1 2 3 4 5 6 7

    //创建一个功能分支 git checkout -b feature-x develop //开发完成后，将功能分支合并到develop分支 git checkout develop git merge --no-ff feature-x //删除feature分支 git branch -d feature-x

• 预发分支（release branch）
  • 它是指发布正式版本之前（即合并到Master分支之前），我们可能需要有一个预发布的版本进行测试。
  • 预发布分支是从Develop分支上面分出来的，预发布结束以后，必须合并进Develop和Master分支
  • 它的命名，可以采用release-*的形式。

    1 2 3 4 5 6 7 8 9 10 11 12

    //创建一个预发布分支 git checkout -b release-1.2 develop //确认没有问题后，合并到master分支 git checkout master git merge --no-ff release-1.2 //对合并生成的新节点，做一个标签 git tag -a 1.2 //再合并到develop分支 git checkout develop git merge --no-ff release-1.2 //最后，删除预发布分支 git branch -d release-1.2

• 补丁分支（hotfix branch）
  • 最后一种是修补bug分支。软件正式发布以后，难免会出现bug。这时就需要创建一个分支，进行bug修补
  • 修补bug分支是从Master分支上面分出来的。修补结束以后，再合并进Master和Develop分支。
  • 它的命名，可以采用fixbug-*的形式。

    1 2 3 4 5 6 7 8 9 10 11

    //创建一个修补bug分支 git checkout -b fixbug-0.1 master //修补结束后，合并到master分支 git checkout master git merge --no-ff fixbug-0.1 git tag -a 0.1.1 //再合并到develop分支 git checkout develop git merge --no-ff fixbug-0.1 //最后，删除"修补bug分支" git branch -d fixbug-0.1

一旦完成开发，它们就会被合并进develop或master，然后被删除

查看更多文章

while

1
2
3
4
5
6
7

let index = 0;
const array = [1,2,3,4,5,6];

while (index < array.length) {
  console.log(array[index]);
  index++;
}

for (classical)

1
2
3
4

const array = [1,2,3,4,5,6];
for (let index = 0; index < array.length; index++) {
  console.log(array[index]);
}

forEach

1
2
3
4
5
6

const array = [1,2,3,4,5,6];

array.forEach(function(current_value, index, array) {
  console.log(`At index ${index} in array ${array} the value is ${current_value}`);
});
// => undefined

map

The last construct was useful, however, it doesn’t return a new array which might be undesirable for your specific case. map solves this by applying a function over every element and then returning the new array.

1
2
3
4
5

const array = [1,2,3,4,5,6];
const square = x => Math.pow(x, 2);
const squares = array.map(square);
console.log(`Original array: ${array}`);
console.log(`Squared array: ${squares}`);

The full signature for map is .map(current_value, index, array).

reduce

From MDN:

The reduce() method applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.

1
2
3
4

const array = [1,2,3,4,5,6];
const sum = (x, y) => x + y;
const array_sum = array.reduce(sum, 0);
console.log(`The sum of array: ${array} is ${array_sum}`);

filter

Filters elements on an array based on a boolean function.

1
2
3
4

const array = [1,2,3,4,5,6];
const even = x => x % 2 === 0;
const even_array = array.filter(even);
console.log(`Even numbers in array ${array}: ${even_array}`);

every

Got an array and want to test if a given condition is met in every element?

1
2
3
4
5
6
7
8

const array = [1,2,3,4,5,6];
const under_seven = x => x < 7;

if (array.every(under_seven)) {
  console.log('Every element in the array is less than 7');
} else {
  console.log('At least one element in the array was bigger than 7');
}

some

Test if at least one element matches our boolean function.

1
2
3
4
5
6
7
8

const array = [1,2,3,9,5,6,4];
const over_seven = x => x > 7;

if (array.some(over_seven)) {
  console.log('At least one element bigger than 7 was found');
} else {
  console.log('No element bigger than 7 was found');
}

查看更多文章

• 熟悉了解需求，及时和产品沟通，和后端协商接口字段格式

对需求了解才能流畅对开发，如果不熟悉会造成开发分歧，返工率会增大，跟后端协调好接口，避免多次修改接口结构

• 开发之前认真阅读之前代码（在之前项目上开发）

熟悉公共组件方法和代码书写方式，对一个陌生的函数需要一直查看到根，能大大提高对整个调用的流程和使用方法。

• 规划代码结构，确保结兼容良好

在写结构的时候尽量考虑结构的稳定性和扩展性，对于周边更改或者需求的更改不会涉及到结构的改动，因为结构的改动可能会影响之前写的业务逻辑，尤其在操作DOM显示的尤为突出

• 抽取公共代码，提高复用率

对于结构相同的页面操作逻辑尽量将他们公共的部分抽取出来，这样可以省去小的变更需要多个页面同时修改； 比如添加和编辑页面的提交页面，可以抽取他们获取表单值的方法

• 尽量将大函数拆封成小函数

尽量将大函数拆封成小函数，方便阅读和修改（由于书写代码习惯和经验的不同，可能会出现代码拆分不够细，导致一个大函数写了很多的方法，导致函数臃肿，不够清晰；将一些必要逻辑拆分成一个个小的方法，不但提高复用率，还能降低代码的耦合性，方便修改和调试）

• 添加必要的注释

防止过后出现阅读障碍，重复阅读代码（作为一个开发者，应该有添加代码注释的好习惯，对于自己开发可以防止代码过多阅读障碍；对于以后参与开发者方便阅读和理解。

• 提高自测质量

对于自己需求的开发，在提测之前一定需要自测，自测时候尽量站在测试或者使用者角度测试周全考虑，及时修复问题，提高自测质量。

• 追求完美

要有对产品的认识和对美的最求（了解产品，开发过程中不但是开发者更是第一使用者，对不合理或者有缺陷的问题应该及时提出，在开发过程中UI的缺陷也应该及时提出）

构造函数

惯例：

构造函数始终应该以一个大写字母开头（借鉴自其他OO语言，因为JavaScript不是一个面向对象（oo）的语言，它只是基于对象（bo）。

构造函数本身也是函数，只不过可以创建对象而已。

构造函数和普通函数没有什么区别，只不过是用new来调用；使用new操作符会经历一下4步：

（1）创建一个新对象；

（2）将构造函数作用域赋给新对象（所以this就指向了这个新对象）；

（3）执行构造函数中的代码（为这个新对象添加属性）

（4）返回新对象

1
2
3
4
5
6
7
8
9
10
11
12
13

function People() {
this.age = 12;
    this.sex = "男";
    this.name = "likai"
}

var people1 = new People()
var people2 = new People()

console.log(people1)      //{age: 12, sex: "男", name: "likai"}
 console.log(people1.age) //12
console.log(people2)      //{age: 12, sex: "男", name: "likai"}
console.log(people2.age)  //12

JS中没有类的概念，我们这里只是和Java、C++、C#做一个类比，JS中只有构造函数而没有类！当一个函数被new操作符调用的时候，它总能返回一类的具有相同属性群的对象，感觉在“构造东西”，所以我们称为构造函数。这个函数很神奇，像一个模子，在制作类似的对象。

判断函数是否为构造函数

是否被new操作符调用

1
2
3
4
5
6
7
8

function Test(a,b){
    this.a = a;
    this.b = b
}
var test = Test(1,2);
var test1 = new Test(3,4)
console.log( test1.a )      //3 
console.log( test.a )       //报错

如果构造函数里写了return情况

1. 如果return这个基本类型值，则无视这个return，该return什么还是return什么，但是return阻止了构造函数的执行；

1
2
3
4
5
6
7
8
9

function Test(a, b, c) {
    this.a = a;
    this.b = b;
    return
    this.c = c;
}

var test = new Test(1, 2, 3)
console.log(test)    //{a: 1, b: 2}

1. 如果return了引用类型值，则返回你return的这个，原有return被覆盖。(new四步走就失效了)

1
2
3
4
5
6
7
8
9

function Test(a, b, c) {
    this.a = a;
    this.b = b;
    return {"g":1, "h": 2}
    this.c = c;
}

var test = new Test(1, 2, 3)
console.log(test)    //{g: 1, h: 2}

原型链

1. prototype

每一个函数天生都有prototype属性，指向一个空对象。也就是说，我们不需要定义这个prototype属性，任何一个函数只要写出来，它就拥有了prototype属性。

当这个构造函数被new的时候，它的每一个实例的proto属性，也指向这个对象

1
2
3
4
5
6
7

function Test(a,b,c) {
    this.a = a;
    this.b = b;
    this.c = c;
}
var test = new Test()
console.log(Test.prototype === test.__proto__) //true

我们称Test.prototype是Test构造函数的“原型”，Test.prototype是test的“原型对象”

2. __propto__

有原型链查找功能。当实例身上没有某个属性的时候，系统会沿着proto去寻找它的原型对象身上有没有这个属性。

1
2
3
4
5
6
7
8
9
10
11
12

function Test(a, b, c) {
    this.a = a;
    this.b = b;
    this.c = c;
}
Test.prototype.init = function () {
    console.log(this.a)
}

var test = new Test(1, 2, 3)
console.log(Test.prototype.init === test.__proto__.init)  //true 
test.init()  //1

3.方法的定义在原型上

我们刚才知道如果把函数写在构造函数里面，就相当于定义在了对象身上，此时函数会产生多个不同副本，影响程序效率。此时可以把函数定义在构造函数的原型上，这样所有new出的东西，proto就会指向这个对象，从而能够使用这个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

function People(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
}
People.prototype.sayHello = function () {
    console.log("你好我是" + this.name + "！我的年龄是" + this.age);
}

// 实例化两个对象
var h1 = new People("小明", 19, "男");  
var h2 = new People("小红", 12, "女");  

// 对象打点调用他们的方法
xiaoming.sayHello();   //你好我是小明！我的年龄是19
xiaohong.sayHello();   //你好我是小红！我的年龄是12

console.log(h1.sayHello === h2.sayHello); //true

4. hasOwnProperty()方法

可以检测一个属性是存在于实例中，还是存在于原型中。这个方法(不 要忘了它是从 Object 继承来的)只在给定属性存在于对象实例中时，才会返回 true。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

function Person() { 

} 
Person.prototype.name = "Nicholas"; Person.prototype.age = 29; 
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function () {
    console.log(this.name);
}

var person1 = new Person();
var person2 = new Person();
console.log(person1.hasOwnProperty("name"));  //false
person1.name = "Greg";
console.log(person1.name); //"Greg"——来自实例 
console.log(person1.hasOwnProperty("name")); //true
console.log(person2.name); //"Nicholas"——来自原型 
console.log(person2.hasOwnProperty("name")); //false
delete person1.name;
console.log(person1.name); //"Nicholas"——来自原型 
console.log(person1.hasOwnProperty("name")); //false

面向对象

1. 为圆选坑
2. carousel-图文轮播

函数的this是什么，取决于函数怎么调用！！而不是函数如何定义！！
函数的this是函数的调用时表现的性质，不是函数定义的时候写死的性质！！

1. 函数使用圆括号调用，函数的this就是window对象

1
2
3
4
5
6

function() {
    var a = 10;
    console.log(this.a)  //实际上访问的是window.a
}
var a = 20;
fun()   //20

• 函数function fun() {}的this不要看他怎么定义，要看他怎么调用； 此时函数是fun() 函数名加圆括号直接调用，此时this就是window对象。

2. 函数作为一个对象的方法，对象打点调用，函数的this就是这个对象

对象.函数()

1
2
3
4
5
6
7
8
9

function() {
    console.log(this.a);
}
var obj = {
    "a" : 10,
    "b" : 20,
    "c" : fn   //对象方法值为函数
}
obj.c()   //10

• 我们要看清楚函数执行的时候，是怎么执行的！！
• 现在不是圆括号直接执行！！而是一个对象打点调用这个函数执行，所以函数的上下文是obj对象！！！

3. 函数是事件处理函数，函数的this就是触发这个事件的对象

1
2
3
4
5
6
7
8
9
10
11
12
13

//定义了一个btnEvent，然后把这个btnEvent当做了2个DOM元素的事件处理函数：
function btnEvent() {
    this.style.background = "#999";
}

var box1 = document.getElementById("box1");
var box2 = document.getElementById("box2");

//把同一个函数绑定给不同的对象
box1.onclick = btnEvent;
box2.onclick = btnEvent;

//函数不会执行，直到用户点击了某一个div标签。此时点击谁，this就是谁。

4. 定时器调用函数，上下文是window对象

1
2
3
4
5
6
7

function fun() {
    console.log(this.a);
}
var a = 99;
setInterval(fun, 1000)

//函数fun被定时器调用，此时函数的this就是window对象。每秒钟打印出99.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//定时器在事件中使用


//错误的写法
var box1 = document.getElementById("box1");
box1.onclick = function(){
	setTimeout(function(){
		this.style.background = "red";
	},2000);
}
//定时器里面的函数调用者是定时器，所以this上下文就是window对象
//解决办法： 备份this


//正确的写法
var box1 = document.getElementById("box1");

box1.onclick = function(){
	var self = this;        //备份this，定时器里面的this就是我们的box1了
	setTimeout(function(){
		self.style.background = "red";
	},2000);
}

5. 数组中存放的函数，被数组索引之后加圆括号调用，this就是这个数组

1
2
3
4
5
6
7
8
9

function fun() {
    console.log(this == arr)  //true
    console.log(this.length)  //3
}
var arr = [fun, "w", "e"]

arr[0]()

//此时这个函数是从数组中枚举出来然后加圆括号执行的，所以最终调用者可以认为是这个数组，上下文就是这个数组。

6. call()和apply()

• 这两个函数都是函数的方法，只有函数能够打点调用call()、apply()，表示用指定的上下文执行这个函数。
• 语法： 函数.call(上下文) || 函数.apply(上下文)
• 区别： 体现在参数上。此时我们要执行的fun函数可以接受参数，apply需要用数组体现这些参数，而call必须用逗号隔开，罗列所有参数：

1
2
3
4
5
6
7
8
9
10
11
12

function fun(a,b,c){
	console.log(a+b+c);
	console.log(this.age);
}

var obj = {
	"name" : "小明",
	"age" : 12
}

fun.call(obj,6,7,8);  // 21  12
fun.apply(obj,[6,7,8]);  // 21  12

函数的arguments

• 首先说说什么是arguments.callee。在函数内部，如果想得到函数自身，用this是不可能的。我们必须使用arguments.callee

  1 2 3 4 5

  function fun(){ console.log(arguments.callee === fun); //true } fun(); //true，因为arguments.callee就是fun自己

1
2
3
4
5
6

function fun(a,b,c,d,e,f){
	console.log(arguments.callee.length);  //6
    console.log(arguments.length);         //3
}

fun(88,66,44);

函数的length是形参列表的长度，就是函数定义的时候写在fun()圆括号里面的字母个数。无视你的实参个数！也就是说：
arguments.callee.length 形参列表的个数。
arguments.length 实参个数，就是调用函数的时候传进来的实参个数。

用new运算符来调用函数(构造函数说明)

一. Arry 对象属性

1. length ：设置或返回数组中元素的数目

   1 2	var arr = [1,2,3,4,5,6] console.log(arr.length) //6

二. Array 方法

1. concat()

• 连接两个或更多的数组，并返回结果

  1 2 3 4

  var arr = [1,2,3] var arr1 = ["w"] console.log(arr.concat("s", arr1)) //[1,2,3,"s"] //

2. join()

• 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。

  1 2 3

  var arr = ["q","w","e"] console.log( arr.join() ) //q,w,e console.log( arr.join("*") ) //q*w*e

3. toString()

• 把数组转换为字符串，并返回结果。

  1 2	var arr = ["q","w","e"] console.log(arr.toString()) //q,w,e

4. pop()

• 删除并返回数组的最后一个元素

  1 2	var arr = ["q","w","e"] console.log(arr.pop()) // e

5. push()

• 向数组的末尾添加一个或更多元素，并返回新的长度。

  1 2 3 4

  var arr = ["q","w","e"] console.log(arr.push("r")) // 4 console.log(arr) // [q", "w", "e", "r"] //

6. shift()

• 删除并返回数组的第一个元素

  1 2	var arr = ["q","w","e"] console.log(arr.shift()) // q

7. unshift()

• 向数组的开头添加一个或更多元素，并返回新的长度。

  1 2 3 4

  var arr = ["q","w","e"] console.log(arr.unshift("t")) // 4 console.log(arr) // ["t", "q", "w", "e"] //

8. slice()

• 从某个已有的数组返回选定的元素
• arr.slice(start,end)
• 只有一个参数：

• 1）为正：从为该参数的下表一直截取到最后；

  1 2 3

  var arr = ["q","w","e","r","t"] console.log(arr.slice(2)) //["e", "r", "t"] //

• 2）为负：从倒数第几个元素截取到最后

  1 2	var arr = ["q","w","e","r","t"] console.log(arr.slice(-2)) //["r", "t"]

• 两个参数

• 1）为正：表示表示从第一个为第一个参数的下标截取到为最后一个参数下标

  1 2	var arr = ["q","w","e","r","t"] console.log(arr.slice(2,4)) //["e", "r"]

• 2）一正一负：表示表示从第一个为第一个参数的下标截取到从倒数为第二个参数的地方；

  1 2	var arr = ["q","w","e","r","t"] console.log(arr.slice(1, -1)) //["w", "e", "r"]

• 3）两个都为负：从倒数第一个参数绝对值的位置截取到第二个参数绝对值的位置（第二个参数的绝对值不小于第一个参数的绝对值）

  1 2	var arr = ["q","w","e","r","t"] console.log(arr.slice(-2, -1)) //["r"]

9. reverse()

• 颠倒数组中元素的顺序。

  1 2	var arr = ["q","w","e","r","t"] console.log(arr.reverse()) //["t", "r", "e", "w", "q"]

10. sort()

• 对数组的元素进行排序

• 1）如果没有参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。（把数组的元素都转换成字符串）

  1 2 3 4 5 6

  var arr = [0, 10, 2, 4, 3, 6] console.log(arr.sort()) //[0, 10, 2, 3, 4, 6] var arr = ["a", "b", "d", "e", "c"] console.log(arr.sort()) //["a", "b", "c", "d", "e"]

• 2)如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  // 若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。 // 若 a 等于 b，则返回 0。 // 若 a 大于 b，则返回一个大于 0 的值。 function sortNumber(a,b) { return a - b } var arr = [1, 3, 5, 8, 10, 23, 44] arr.sort(sortNumber) //[1, 3, 5, 8, 10, 23, 44] function sortNumber(a,b) { return b - a } var arr = [1, 3, 5, 8, 10, 23, 44] console.log( arr.sort(sortNumber)) //[44, 23, 10, 8, 5, 3, 1]

11. splice()

• 向/从数组中添加/删除项目，然后返回被删除的项目

• 1-1)一个参数表示从为该参数的下标截取到最后

  1 2 3

  var arr = [1,2,3,4,5,6] console.log(arr.splice(1)) //[2, 3, 4, 5, 6] console.log(arr) //[1]

• 1-2)一个参数为负表示从后面为第一个参数开始截取到最后

  1 2 3

  var arr = [1,2,3,4,5,6] console.log(arr.splice(-1)) //[6] console.log(arr) //[1, 2, 3, 4, 5]

• 2-1） 两个参数表示从为以一个参数的下标向后截取为第二个参数个

  1 2 3

  var arr = [1,2,3,4,5,6] console.log(arr.splice(2, 4)) //[3, 4, 5, 6] console.log(arr) //[1, 2]

• 2-2) 一正一负表示从后面为第一个参数开始截取为第二个参数的个数

  1 2 3

  var arr = [1,2,3,4,5,6] console.log(arr.splice(-4, 2)) //[3,4] console.log(arr) //[1,2,5,6]

• 3)三个参数

• 第一个参数表示开始的下标位置，第二个参数表示从为第一个参数的下标开始替换的个数，（0表示插入）； 第三个参数表示替换或插入的元素

  1 2 3 4 5 6 7 8 9

  //第二个参数为0 var arr = [1,2,3,4,5,6] arr.splice(1, 0, "w") console.log(arr) //[1, "w", 2, 3, 4, 5, 6] //第二个参数不为0 var arr = [1,2,3,4,5,6] arr.splice(1, 2, "w") console.log(arr) //[1, "w", 4, 5, 6]

12. toLocaleString()

• 把数组转换为本地字符串，并返回本地字符串表示。

  1 2	var arr = ["a", "b", "d", "e", "c"] console.log(arr.toLocaleString()) //a,b,d,e,c

• String 对象是 String
• 原始类型的对象表示法，它是以下方式创建的：

1
2
3

var str1 = new String("hello world!");
//普通写法
var str2 = "hello world!"

1. length属性
   • 返回值：返回字符串个数（每个空格也算一个）

1
2

var str = "wwww"
console.log(str.length)   // 4

1. valueOf() 方法和 toString() 方法
   • 返回值：stringObject 的原始字符串值

1
2
3
4

var str = "hello world!"
str.valueOf()  //"hello world!"
str.toString() //"hello world!"
console.log(str.valueOf() == str.toString()) //true

1. charAt() 和 charCodeAt() 方法
   • charAt() 返回的是指定位置的字符串
   • charCodeAt() 返回在指定的位置的字符的 Unicode 编码
   • 访问的是单个字符串的单个字符，这样两个方法都有一个参数（要操作字符的位置）

1
2
3

var str = "qwerty"
console.log( str.charAt(1) )  //w
console.log( str.charCodeAt(1) ) //119

1. concat() 方法
   • 连接字符串

1
2
3
4

var str = "ss"
var str2 = "ww" 
console.log( str.concat("vv") )  //"ssvv"
console.log( str.concat(str2) )   // "ssww"

1. indexOf() 和 lastIndexOf() 方法
   • indexOf() 和 lastIndexOf() 方法返回的都是指定的子串在另一个字符串中的位置，如果没有找不到子串，则返回 -1。
   • 区别：indexOf() 方法是从字符串的开头（位置 0）开始检索字符串，而 lastIndexOf() 方法则是从字符串的结尾开始检索子串。

1
2
3

var str = "hello world!"
console.log( str.indexOf("d") )  // 10
console.log( str.lastIndexOf("d") )  // 1

1. slice() 和 substring()
   • 返回值： 一个新的字符串数
   • 参数： 接受一个或者两个参数，一个参数表示从该参数位置截取到最后，两个参数表示从第一个参数位置开始截取第二个参数的位置
   • 如果参数为负数，slice()表示从反方向截取; substring()会将负数解释为0，还会将小的数字作为起始位置;

1
2
3
4
5
6
7
8
9
10
11
12
13

var str = "hello world!"
console.log( str.slice(3) )         //输出 "lo world"
console.log( str.substring(3) )     //输出 "lo world"
console.log( str.slice(3, 7) )      //输出 "lo w"
console.log( str.substring(3, 7) )  //输出 "lo w"

//如果参数为负数，slice()表示从反方向截取; substring()会将负数解释为0，还会将小的数字作为起始位置;

var str = "hello world!"
console.log( str.slice(-3) )         //输出 "rld"
console.log( str.substring(-3) )     //解释为substring(0); 输出 "hello world"
console.log( str.slice(3, -4) )      //输出 "lo w"
console.log( str.substring(3, -4) )  //解释为substring(0, 3); 输出 "hel"

1. split()方法
   • 用于把一个字符串分割成字符串数组
   • 返回值： 一个字符串数组

1
2
3
4

var str = "hello world!"

console.log( str.split(" ") )  //["hello", "world!"]
console.log( str.split(" ") )  //["hello", "world!"]

1. toLowerCase()、toLocaleLowerCase()、toUpperCase() 和 toLocaleUpperCase()
   • 执行大小写转换
   • 返回值：一个新的字符串

1
2
3
4
5

var str = "hello world!"
console.log( str.toLocaleUpperCase() ) //输出 "HELLO WORLD!"
console.log( str.toUpperCase() )		//输出 "HELLO WORLD!"
console.log( str.toLocaleLowerCase() )	//输出 "hello world!"
console.log( str.toLowerCase() )		//输出 "hello world!"

1. match()
   • 字符串内检索指定的值，或找到一个或多个正则表达式的匹配
   • 但是它返回指定的值，而不是字符串的位置
   • 返回值： 存放匹配结果的数组

1
2
3

var str="1 plus 2 equal 3"
console.log( str.match(/plus/g) )   // ["plus"]
console.log( str.match(/\d+/g) )    //["1", "2", "3"]

1. search()
   • 返回第一个与 regexp 相匹配的子串的起始位置。
   • 如果没有找到任何匹配的子串，则返回 -1。

1
2
3

var str = "hello world!"
console.log( str.search(/world/) )  //6
console.log( str.search(/sds/) )    // -1

1. replace()
   • 返回一个新的字符串
   • 在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串

1
2

var newStr = str1.replace("hello", "你好")   //你好 world!
var newStr = str.replace(/l/g, "K")          //heKKo worKd!

1
2
3
4

//第一个参数是正则，第二个参数是带$符的字符串
var str3 = '这是一段原始文本,"3c这要替换4d"!';
var newStr = str3.replace( /([0-9])([a-z])/g,"$1" );
console.log( newStr );    //输出：    这是一段原始文本,"3这要替换4"!';

• 上面的例子，$1表示regexp中的第一个子表示即（[0-9]）匹配单个数字，同理若是$2则表示第二个子表示即（[a-z]）；所以，’3c’这个匹配到的整体被第一个子表示说表示的’3’替换，’4d’被第一个子表示匹配的数字’4’所替换。其他几个同理可得：

• （/([0-9])([a-z])/g,”$2″）—>////输出： 这是一段原始文本,”c这要替换d”!’; (3c和4d被相应的第二个子表示匹配出来的c和d替换)

• （/([0-9])([a-z])/g,”$’”）—>////输出： 这是一段原始文本,”这要替换d”!这要替换”!”!’; (3c被3c右侧文本替换，4d右侧是”!替换，所以出现俩次)

1
2
3
4
5
6
7
8
9
10

// 第一个参数是正则，第二个参数函数
var str4 = '这是一段原始文本，需要替换的内容"aa这要bbb替换ccccc"！';
var newStr = str4.replace( /[a-z]+/g,function ($0){
    var str = '';
    for (var i = 0; i < $0.length; i++) {
        str += '*';
    };
    return str;
} );
console.log( newStr );   //这是一段原始文本，需要替换的内容"**这要***替换*****"！

• 上面的例子函数的第一个参数为匹配的regexp的整体，根据长度函数返回值为相应替换的文本；

克隆、新建、删除分支

• 克隆仓库

  1	git clone XXX

• 新建并切换到本地分支

  1	git checkout -b XXX

• 本地代码合并到远程分支

  1	git push origin XXX

• 拉取运程分支

  1	git pull origin XXX

• 查看分支

  1 2	git branch -a //查看远程分支 git branch //查看本地分支

• 切换到分支

  1	git checkout XXX

• 删除分支

  1 2	git branch -d XXX //删除本地分支 git push origin --delete XXX //删除远程分支

项目提交操作

• 添加项目到暂存区（stage）

1

$ git add .

• 查看状态

1

$ git status

• 将暂存区中所有修改提交到分支仓库中

1
2
3

$ git commit -m "XXX"
//-m 后面紧跟着的是对当前版本的一段描述话语，方便以后再分支仓库中快速找到某个版本；
//注意：这里要用双引号，不能用单引号

查看版本日志信息

• 查看某个分支仓库中的版本信息

1
2
3
4
5

$ git log
//commit：每创建一条版本信息时，都会用 SHA1 生成一个很大的数字，并用十六进制进行表示，目的是根据这个 commit id可以找到对应的版本信息，不会重复。
//Author：提交这条版本信息的人是谁，适用于团队开发时，记录每个版本是谁提交的，这样出了问题也好找对应的负责人解决问题。
//Date：这个就是提交到分支仓库的时间了。
//版本描述信息，如果没有它，你看到的只是一大串数字，压根不知道这条版本到底做了哪些修改。

• 感觉日志信息输出太多，可以使用 git log –pretty=oneline 在一行显示日志

1
2
3
4
5

$ git log --pretty=oneline
//输出
ad489d062e14dfe87d0d611e0a98f4345eaa7305 (HEAD -> master, origin/master, origin/HEAD) [02]commit add flie
5792db2ce7891a5b5973d2b1fadce523fbcc7a7c [01]commit test flie
5a5c7081f9bcc077477d6181f7a6a6c2eac522d9 Initial commit

回滚到指定版本

• 使用 git reset –hard 指令进行版本回滚

1
2
3
4

$ git reset --hard 5792db2c

//说明：
//--hard后面跟着的字符串是要回滚到的那条版本信息对应的 commit id，当然不需要全部写，只需要截取前面7-8位唯一标识即可。

• 使用 git reflog 指令查看刚才所有操作日志

1

$ git reflog

git log 与git reflog 区别

• git log：只查询文件修改/新增/删除等与文件有关的日志记录；
• git reflog：不仅记录与文件有关的记录，还会记录对分支仓库的回滚记录。

1. 确认自己是否已经拥有密钥

为了向 Git 服务器提供 SSH 公钥，如果某系统用户尚未拥有密钥，必须事先为其生成一份。 这个过程在所有操作系统上都是相似的。 首先，你需要确认自己是否已经拥有密钥。 默认情况下，用户的 SSH 密钥存储在其 ~/.ssh 目录下。 进入该目录并列出其中内容，你便可以快速确认自己是否已拥有密钥：

1
2
3
4

$ cd ~/.ssh
$ ls
authorized_keys2  id_dsa       known_hosts
config            id_dsa.pub

2. 生成SSH key

我们需要寻找一对以 id_dsa 或 id_rsa 命名的文件，其中一个带有 .pub 扩展名。 .pub 文件是你的公钥，另一个则是私钥。 如果找不到这样的文件（或者根本没有 .ssh 目录），你可以通过运行 ssh-keygen 程序来创建它们

1
2
3
4
5
6
7
8
9
10

$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/schacon/.ssh/id_rsa):
Created directory '/home/schacon/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/schacon/.ssh/id_rsa.
Your public key has been saved in /home/schacon/.ssh/id_rsa.pub.
The key fingerprint is:
d0:82:24:8e:d7:f1:bb:9b:33:53:96:93:49:da:9b:e3 schacon@mylaptop.local

首先 ssh-keygen 会确认密钥的存储位置（默认是 .ssh/id_rsa），然后它会要求你输入两次密钥口令。如果你不想在使用密钥时输入口令，将其留空即可。

3. 查看key

1
2

cat ~/.ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC+X1iMFBvyEE3WJQ/SMHsrC8hVxoWa4XIZtybbKnLsgA3UPJHYN66AU7uvfy9JAGQNaxV4T8JBQGoVy+7of8LklhOLXeLu4hvUnw4dyCEVZXLmM/rGGfHHvaJ8jqmq46NYzq25pIbxkAGhgfOnxYZuDBxdKwBXuhMxXiqDL7SKSNpiV5AJ8/wvX9wLDw5rd2sanjUvOEGzVXlYxMXIss97TVWajSYubkGbIrMrYHmRWRa95UXuhCja8yFE1Hp0Vk8UxpZ0AU677v+Jj6p4fSVEGe8AzgETdQUQcgQk6C6lRj7KC8/BmRGrB0DdfimPjiCcXeJoFsUcG6w9dtE4wGVL wb-likai@cai-inc.com