ife2018 #day22-24 字符串 对象 数组 队列 栈

字符串

• string.length 获取长度
  string[string.length-1] 获取最后一个字符

• stringA.concat(stringB) 将B连接到A后面，数组适用

• string.indexOf('childString') 搜索第一次出现子字符串的位置
  返回开始的index，若不存在子字符串，返回-1

• string.lastIndexOf('childString') 搜索最后一次出现子字符串的位置

• string.slice(startIndex, endIndex) 提取子字符串
  不包括最后一个字符
  string.slice(3) 从3开始到最后一个字符

• string.substr(startIndex, length) 提取子字符串
  string.substr(3) 从3开始到最后一个字符

• 大小写转换
  radData.toLowerCase();
radData.toUpperCase();

• 替换字符
  browserType.replace('moz','van'); 将第一个参数内容替换为第二个参数

• 大写修正（首字母大写）

var list = document.querySelector('.output ul');
list.innerHTML = '';
var cities = ['lonDon', 'ManCHESTer', 'BiRmiNGHAM', 'liVERpoOL'];

for(var i = 0; i < cities.length; i++) {
  var input = cities[i];
  var lower = input.toLowerCase();//转换为小写
  var firstLetter = lower.slice(0,1);//首字母分离
  var capitalized = lower.replace(firstLetter,firstLetter.toUpperCase());//替换首字母
  var result = capitalized;
  var listItem = document.createElement('li');
  listItem.textContent = result;
  list.appendChild(listItem);
}

对象

• var person = {}; 创建空对象
• 创建语法

var objectName = {
  member1Name : member1Value,
  member2Name : member2Value,
  member3Name : member3Value
}

• 例子：对象的字面量(literal)——手动的写出对象的内容来创建一个对象

var person = {
  //对象的属性(property)
  name : ['Bob', 'Smith'],   //array
  age : 32,                  //number
  gender : 'male',           //string
  interests : ['music', 'skiing'], //array

  //对象的方法(method)
  bio : function() {
    alert(this.name[0] + ' ' + this.name[1] + ' is ' + this.age + ' years old. He likes ' + this.interests[0] + ' and ' + this.interests[1] + '.');
  },  //function
  greeting: function() {
    alert('Hi! I\'m ' + this.name[0] + '.');
  }   //function，最后一个成员后不加逗号
};

• 访问
  1. 点表示法(dot notation)

  person.age
  person.interests[1]
  person.bio()
  

  2. 括号表示法(bracket notation)

  person['age']
  person['name']['first']
  

  括号表示法一个有用的地方是它不仅可以动态的去设置对象成员的值，还可以动态的去设置成员的名字。
  比如说，我们想让用户能够在他们的数据里存储自己定义的值类型，通过两个input框来输入成员的名字和值，通过以下代码获取用户输入的值：

  var myDataName = nameInput.value
  var myDataValue = nameValue.value
  

  我们可以这样把这个新的成员的名字和值加到person对象里：

  person[myDataName] = myDataValue
  

• 子命名空间

name : {
  first : 'Bob',
  last : 'Smith'
},

//访问时
person.name.first;
person.name.last;

• 直接创建新成员

person.farewell = function() { alert("Bye everybody!") }
person['eyes'] = 'hazel'

• 排序

  对象可以按照某个属性排序：

  var items = [
    { name: 'Edward', value: 21 },
    { name: 'Sharpe', value: 37 },
    { name: 'And', value: 45 },
    { name: 'The', value: -12 },
    { name: 'Magnetic' },
    { name: 'Zeros', value: 37 }
  ];
  
  // sort by value
  items.sort(function (a, b) {
    return (a.value - b.value)
  });
  
  // sort by name
  items.sort(function(a, b) {
    var nameA = a.name.toUpperCase(); // ignore upper and  lowercase
    var nameB = b.name.toUpperCase(); // ignore upper and lowercase
    if (nameA < nameB) {
      return -1;
    }
    if (nameA > nameB) {
      return 1;
    }
  
    // names must be equal
    return 0;
  });
  

数组

• 常用方法

  str.split("-") 将字符串转换为数组，参数为分隔符
  arr.join("-") 将数组用分隔符连接转为字符串
  pop()删除并返回数组的最后一个元素
  push()向数组的末尾添加一个或更多元素，并返回新的长度
  reverse()颠倒数组中元素的顺序
  shift()删除并返回数组的第一个元素
  slice()从某个已有的数组返回选定的元素
  sort()对数组的元素进行排序
  splice()删除元素，并向数组添加新元素
  toSource()返回该对象的源代码
  toString()把数组转换为字符串，并返回结果
  unshift()向数组的开头添加一个或更多元素，并返回新的长度

• 数组的深拷贝

  1. for 循环
  2. slice 方法
  3. concat 方法
  4. ES6扩展运算符

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

• 排序

  arr.sort([compareFunction])

  • 如果没有指明 compareFunction ，那么元素会按照转换为的字符串的诸个字符的Unicode位点进行排序。
  • 如果指明了 compareFunction ，那么数组会按照调用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：
    1.如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
    2.如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；
    3.如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
    compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。
    例子

  function compare(a, b) {
    if (a < b ) {           // 按某种排序标准进行比较, a 小于 b
      return -1;
    }
    if (a > b ) {
      return 1;
    }
    // a must be equal to b
    return 0;
  }
  

  sort 方法可以使用 函数表达式 方便地书写

  var numbers = [4, 2, 5, 1, 3];
  numbers.sort(function(a, b) {
    return a - b;
  });
  console.log(numbers);
  
  也可以写成：
  var numbers = [4, 2, 5, 1, 3]; 
  numbers.sort((a, b) => a - b); 
  console.log(numbers);
  
  // [1, 2, 3, 4, 5]
  

• 对非 ASCII 字符排序

• 使用映射改善排序

队列

队列-百度百科

• 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。
  又称为先进先出（FIFO—first in first out）线性表

• 顺序队列

  建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间，并设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置，如下图：

  
  
  

  当front=rear时，队列中没有任何元素，称为空队列。

• 循环队列

  在实际使用队列时，为了使队列空间能重复使用，往往对队列的使用方法稍加改进：无论插入或删除，一旦rear指针增1或front指针增1 时超出了所分配的队列空间，就让它指向这片连续空间的起始位置。自己真从MaxSize-1增1变到0，可用取余运算rear%MaxSize和front%MaxSize来实现。这实际上是把队列空间想象成一个环形空间，环形空间中的存储单元循环使用，用这种方法管理的队列也就称为循环队列。除了一些简单应用之外，真正实用的队列是循环队列。

  在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件时front=rear，而队列判满的条件时front=（rear+1）%MaxSize。队空和队满的情况如图：

  
  
  

栈

栈-百度百科
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为后进先出表。