js学习笔记(一)

1.数组实用方法大全

 //给数组添加个方法，返回数组中的最大值
 Array.prototype.max = function() {
     return Math.max.apply(null,this);
 }
 [1,2,3,4].max(); //

 //给数组添加个方法，给数组去重
 Array.prototype.unique = function() {
     return this.filter((item, index, arr) => arr.indexOf(item) === index);
 }
 [11,2,1,1,2,3,1,2,4,5,23,2].unique(); //[11, 2, 1, 3, 4, 5, 23]

 var arr = [];
 function distinct(arr){
      return arr.filter(function(ele,index,arr){
                 return arr.indexof(ele,index+1)==-1
 })
 }
7// 这个方法也可以用来去重

Array.isArray()在ES5之前不支持，就自己写。不过现在都到ES6了，可以不管了。

 Array.prototype.isArray = Array.prototype.isArray || function() {
     return Object.prototype.toString.call(this) === "[object Array]";
 }
 [1,2,3].isArray(); //true

数组的遍历

 for (var index = 0; index < arr.length; index++) {
     console.log(arr[index]);
 } //这种写法简洁，但这种方法也有一个小缺陷：你不能使用break语句中断循环，也不能使用return语句返回到外层函数。

 for (var value of arr) {
     if(value == 2){break;}
     console.log(value);  //
 } //这是最简洁、最直接的遍历数组元素的语法。这个方法避开了for-in循环的所有缺陷。与forEach()不同的是，它可以正确响应break、continue和return语句。

splice插入、删除、换数

 var arr = ["q","w","e"];
 //删除
 var removed = arr.splice(1,1);
 console.log(arr); //q,e  已被改变
 console.log(removed); //w ,返回删除的项
 //插入
 var insert = arr.splice(0,0,"r"); //从第0个位置开始插入
 console.log(insert); //返回空数组
 console.log(arr); //r,q,e
 //替换
 var replace = arr.splice(1,1,"t"); //删除一项，插入一项
 console.log(arr); //r,t,e
 console.log(replace); //q,返回删除的项 

sort() 方法对数组的元素做原地的排序，并返回这个数组。

 var arr = [1,2,4,3,1,1,2];
 console.log(arr.sort());//[1, 1, 1, 2, 2, 3, 4]

 然而：
 var arr = [1,2,10,4,3,1,1,2];
 console.log(arr.sort());//[1, 1, 1, 10, 2, 2, 3, 4]

这是因为sort排序可能是不稳定的，默认按照字符串的Unicode码位点排序。

 var arr = [1,2,10,4,3,1,1,2];
 console.log(arr.sort(function(a,b){
     return a-b;
 })); // [1, 1, 1, 2, 2, 3, 4, 10]
 //这个函数就是我们自己控制了，我们想要什么样的排序就改变这个参数函数的逻辑即可。

var aa= [1,4,3,2,8,7]; aa.sort(function(){return Math.random()-0.5;}) ; console.log(aa); //随意打乱数组

slice截取、转化arguments伪数组

 function test() {
     var arr = arguments;
     arr.push('xza');
     console.log(JSON.stringify(arr));
 }
 test(1,2,3);  //arr.push is not a function(…) 因为伪数组没有push方法

 转换后：
 function test() {
     var arr = Array.prototype.slice.call(arguments);
     arr.push('xza');
     console.log(JSON.stringify(arr));
 }
 test(1,2,3); //[1,2,3,"xza"]
 //slice方法经常用来截取一个数组，不过它更常用在将伪数组转化为真数组。平时我们的函数传的参数arguments是一个伪数组，很多数组的方法不能使用，我们就需要将伪数组转化为真数组。

 var arr1 = [1,2,3];
 var arr2 = [4,5,6];
 var arr3 = arr1.concat(arr2);  //[1, 2, 3, 4, 5, 6]
 arr3.concat(7); //[1, 2, 3, 4, 5, 6, 7]
 //我们平时都是这么使用的，如果需要连接两个数组的元素时，中间插元素，可以

 var arr3 = arr1.concat('xzavier', arr2); //[1, 2, 3, "xzavier", 4, 5, 6]

其他方法

方法                使用
concat()         连接两个或更多的数组，并返回结果。
join()           把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
reverse()        颠倒数组中元素的顺序。
toString()       把数组转换为字符串，并返回结果。
toLocaleString() 把数组转换为本地数组，并返回结果。
valueOf()        返回数组对象的原始值
map()            返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。
every()          测试数组的所有元素是否都通过了指定函数的测试。
some()           测试数组中的某些元素是否通过了指定函数的测试。

 ar arr = ['xzavier',123,'jser'];
 console.log(arr.valueOf());  //['xzavier',123,'jser']
 console.log(arr.toString());  //xzavier,123,jser
 console.log(arr.toLocaleString());  //xzavier,123,jser
 var arr = ['xzavier',123,'jser'];
 console.log(arr.join(','));     //xzavier,123,jser
 var arr = [1,2,3];
 console.log(arr.reverse());     //[3,2,1]
 var numbers = [1, 4, 9];
 var roots = numbers.map(Math.sqrt); //[1,2,3]
 numbers //[1,4,9]
 roots // [1,2,3]
 [2, 5, 1, 4, 3].some(function (element, index, array) {
     return (element >= 10);
 });  //false
 [2, 5, 1, 4, 13].some(function (element, index, array) {
     return (element >= 10);
 });  //true
 [2, 5, 1, 4, 13].every(function (element, index, array) {
     return (element >= 10);
 });  //false
 [2, 5, 1, 4, 13].every(function (element, index, array) {
     return (element >= 0);
 });  //true

思考题：有两个字符串s1和s2，值只能为a-z。现写一函数，返回一个新的升序的字符串，其值由s1、s2中的值组成，要求包含最多字符且不能重复。

 a = "xyaabbbccccdefww"
 b = "xxxxyyyyabklmopq"
 longest(a, b) -> "abcdefklmopqwxy

 //第一种方案
 function longest(s1, s2) {
       let distStr,
           value,
           distArr = []
       getDistinct(distArr, s1 + s2)
       // 数组排序并转成字符串
       distStr = distArr.sort().join('')
       return distStr
     }
     // 数组去重
     function getDistinct(target, source) {
       let value
       // 将字符串转成数组
       source = Array.from(source) //es6方法
       for(value of source) {
         // 如果target数组中没有该value，则将其添加到数组中
         if(!target.includes(value)) {
           target.push(value)
         }
       }
     }

用ES6中提供的Set数据结构对字符串（s1+s2）“去重”，然后结构赋值得到数组，最后进行排序并转成字符串

const longest = (s1, s2) => [...new Set(s1+s2)].sort().join('')

2.表单操作实例

利用焦点事件（focus 事件），在文本框获得焦点时，利用其 select() 方法选中所有文本。

 var test = document.getElementById("test");
 test.addEventListener("focus",function(){
   test.select();
 },false);

利用 keyup 事件检测用户输入新字符后，文本框内的字符串是否已经达到最大长度，若达到最大长度，则将焦点切换至下一个文本框。

 // form4  自动切换焦点
 (function() {
   function nextFocus() {
     var target = event.target; //target  促发keyup事件的表单元素
     if (target.value.length === target.maxLength) {
       for (let i = 0; i < form4.elements.length; i++) {
         if (form4.elements[i] === target) {
           if (form4.elements[i + 1]) {
             form4.elements[i + 1].focus(); //获得焦点
           }
           return;
         }
       }
     }
   }
   form4.addEventListener("keyup", nextFocus, false);
 })();

HTML5 也规定了一组 JavaScript 属性方法，用来增强自定义表单验证机制。最常用的就是 setCustomValidity() 方法，基于这个方法可以针对特定字段编写自定义的验证逻辑，并强制利用 HTML5 的验证机制。

 <form action="#">
     <p>评论框</p>
     <textarea name="comment" id="comment" cols="30" rows="10" placeholder="写点什么吧"></textarea>
     <br/>
     <input type="submit" value="评论" />
   </form>

 (function(){
   var comment = document.getElementById("comment");
   comment.oninput = function(){  //oninput事件自行查询
     if(comment.value.length < 20){
       comment.setCustomValidity("客官，再多写点嘛！");  //当表单提交时会检查
     }else{
       comment.setCustomValidity("");
     }
   };
 })();

select选择框事件合集

 <form id="form7" action="#">
   <select name="country" id="test">
     <option value="China">中国</option>
     <option value="Amercian">美国</option>
     <option value="England">英国</option>
     <option value="Japan">日本</option>
     <option value="Russia">俄罗斯</option>
   </select>
 </form>
 <hr/>
 <button id="btn1">显示所有的元素</button>
 <button id="btn2">获得当前选中元素的索引</button>
 <button id="btn3">添加新 option 到最后位置</button>
 <button id="btn4">移除第一个 option</button>

 var form7 = document.getElementById("form7");

 var btn1 = document.getElementById("btn1");
 var btn2 = document.getElementById("btn2");
 var btn3 = document.getElementById("btn3");
 var btn4 = document.getElementById("btn4");

 var select = form7.elements[0];
 btn1.onclick = function(){
   select.size = select.length; //所有选择都会显示
 };
 btn2.onclick = function(){
   alert("当前索引："+select.selectedIndex);
 };
 var count=0;
 btn3.onclick = function(){
   var newOption = new Option("国家 "+count,"Country "+count); //注意参数是 option(text,value)
   count++;
   select.add(newOption,undefined); //添加option
 };
 btn4.onclick = function(){
   select.remove(0);
 };

3.模块化js代码

通过在模块内部保留对公共API对象的内部引用，这样就可以在内部对模块实例进行修改，包括添加、删除方法和属性

 function CoolModule(){
     var something = 'cool';
     var another = [1,2,3];
     function change() {
         pubicAPI.doSomething = doAnother;
     }
     function doSomething(){
         console.log( something);
     }
     function doAnother(){
         console.log(another.join('!'));
     }
     var pubicAPI = {
         change: change,
         doSomething: doSomething
     };
     return pubicAPI;
 }
 var foo = CoolModule();
 foo.doSomething(); //cool
 foo.change();
 foo.doSomething(); //1!2!3
 var foo1 = CoolModule();
 foo1.doSomething(); //cool

大多数模块依赖加载器或管理器，本质上都是将这种模块定义封装进一个友好的API

 var MyModules = (function Manager() {
     var modules = {};
     function define(name, deps, impl) {
         for(var i=0; i<deps.length; i++){
             deps[i] = modules[deps[i]];
         }
         modules[name] = impl.apply(impl,deps); //模块依赖impl函数
     }
     function get(name) {
         return modules[name];
     }
     return {
         define: define,
         get: get
     };
 })();

以上代码的核心是modules[name] = impl.apply(impl,deps);，为了模块的定义引入了包装函数(可以传入任何依赖)，并且将模块的API存储在一个根据名字来管理的模块列表modules对象中；

 MyModules.define('bar',[],function () {
     function hello(who) {
         return 'let me introduce: '+who;
     }
     return{
         hello: hello
     };
 });  //module[bar] = {hello:hello}
 MyModules.define('foo',['bar'],function (bar) {
     var hungry = 'hippo';
     function awesome() {
         console.log(bar.hello(hungry).toUpperCase());
     }
     return {
         awesome: awesome
     };
 });
 var foo = MyModules.get('foo');
 foo.awesome();//LET ME INTRODUCE: HIPPO

CommonJS规范是服务器端Javascript模块规范。

Node.js的模块系统，就是参照CommonJS规范实现的。NPM也遵循了commonJS定义的包规范，从而形成了一套完整的生态系统。

CommonJS定义的模块分为:{模块引用(require)} {模块定义(exports)} {模块标识(module)}。require()用来引入外部模块；exports对象用于导出当前模块的方法或变量，唯一的导出口；module对象就代表模块本身。

 //mathCommonJS.js
 function MathClass() {
 }
 MathClass.PI = 3.14;
 MathClass.E = 2.72;
 MathClass.prototype.add = function(a, b) {
     return a+b;
 };
 module.exports = MathClass;

 var MathClass = require('./mathCommonJS.js');
 Page( {
     onLoad: function() {
         console.log( "PI: " +MathClass.PI );
         var mathClass = new MathClass();
         console.log( "3 + 4: " +mathClass.add(3, 4) );
     }
 });

AMD模块的写法

require.js加载的模块，采用AMD规范。也就是说，模块必须按照AMD的规定来写。

假定现在有一个math.js文件，它定义了一个math模块。那么，math.js就要这样写：

 // math.js
 　　define(function (){
 　　　　var add = function (x,y){
 　　　　　　return x+y;
 　　　　};
 　　　　return {
 　　　　　　add: add
 　　　　};
 　　});

 // main.js
 　　require(['math'], function (math){
 　　　　alert(math.add(1,1));
 　　});

如果这个模块还依赖其他模块，那么define()函数的第一个参数，必须是一个数组，指明该模块的依赖性。

 define(['myLib'], function(myLib){
 　　　　function foo(){
 　　　　　　myLib.doSomething();
 　　　　}
 　　　　return {
 　　　　　　foo : foo
 　　　　};
 　　});

4.函数式编程

Functions that operate on other functions, either by taking them as arguments or by returning them, are called higher-order functions.

 //把函数当成变量
 var foo = (x) => console.log(x)
 //把函数当作参数传入另一个函数
 var bar = (y, fn) => fn(y)
 foo('FP is good') // FP is good
 bar('FP is great', foo) //FP is great

如果用函数式编程的思维遍历数组元素:

 function forEach(arr, fn) {
   for (let i = 0; i < arr.length; i++) {
     fn(i, arr[i], arr)
   }
 }

 forEach(arr, (index, value) => console.log(`index: ${index}, value: ${value}`))

废话少说，直接上干货

var animals = [
  {name: 'a' , species: 'dog', weight: 11},
  {name: 'b', species: 'cat', weight: 10},
  {name: 'c', species: 'fish', weight: 1},
  {name: 'd', species: 'cat', weight: 8},
  {name: 'e', species: 'rabbit', weight: 3}
]

// 找到所有种类为猫的动物
animals.filter((animal) => animal.species === 'cat')
// [ { name: 'b', species: 'cat' }, { name: 'd', species: 'cat' } ]

// 返回所有动物的名字
animals.map((animal) => animal.name)
// [ 'a', 'b', 'c', 'd', 'e' ]

// 最重动物的体重  这里的reduce方法参数要搞清楚
animals.reduce((pre, cur) =>(pre.weight>cur.weight?pre:cur))
//Object {name: "g", species: "dog", weight: 111}

给定一个字符串"abcdaabc"统计每个字符的出现次数.

 // 一般做法是这样的
 var str="abcdaabcffffgggggg"
 var count = {};
 var i;

 for(i=0;i<str.length;i++){
     var chr = arr.charAt(i);
     if( typeof count[chr] === "undefined"){
         count[chr] = 1;
     }else{
         count[chr]++;
     }
 }

 // 利用函数式编程思想的方法是这样的
 var res = str.split('')
              .reduce((pre, cur) => (pre[cur]++ || (pre[cur] = 1), pre), {})
   //Object {a: 3, b: 2, c: 2, d: 1, f: 4…}

统计文本中出现频率最高的十个单词

 var fs = require('fs');
 var content = fs.readFileSync('words.txt').toString();
 var words = content.split(/[\s.,\/:\n]+/);
 // 把单词全部变为小写并利用上一个例子的方法统计单词出现的次数
 var tally = words.map((word) => word.toLowerCase())
                  .reduce((pre, cur) => (pre[cur]++ || (pre[cur]=1), pre), {}) //和上面的例子一样 统计出出现次数
 //把object的key变成数组并进行排序
 var top10 = Object.keys(tally)
                   .map((key) => {
                     return {word: key, count: tally[key]}
                   })
                   .sort((a, b) => b.count - a.count) //逆序排序
                   .slice(0, 10)
 console.log(top10)