js基础编程

1.查找数组元素位置
如果数组中存在item，则返回元素在数组中的位置，否则返回-1

function indexOf(arr, item) {
    for(var i=0;i<arr.length;i++){
        if(arr[i]==item){
            return i;
        }
    }
    return -1;
}

2.数组求和
数组中的元素均为Number类型

function sum(arr) {
    var sum = 0;
    for(var i=0;i<arr.length;i++){
        sum +=arr[i];
    }
    return sum;
}

3.移除数组中的元素
移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组

function remove(arr, item) {
    var arr1 =[];
    for(var i=0; i<arr.length;i++){
        if(arr[i]!==item){
            arr1.push(arr[i]);
        }
    }
    return arr1;
}

4.移除数组中的元素
移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回 。（关键：数组的长度是变化的）

function removeWithoutCopy(arr, item) {
    for(var i=0;i<arr.length;i++){
        if(arr[i]==item){
            arr.splice(i,1);
            i--;    //当数组删除一个相同  的数字的时候，数组的长度是变化的。
        }
    }
    return arr;
}

5.添加元素
在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组

function append(arr, item) {
    var arr1 = arr.concat(item);
    return arr1;
}

6.删除数组最后一个元素
删除数组 arr 最后一个元素。不要直接修改数组arr，结果返回新的数组

function truncate(arr) {
    var arr1 = arr.slice(0);
    arr1.pop();
    return arr1;
}

7.添加元素
在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组

function prepend(arr, item) {
    var arr1 = arr.slice(0);
    arr1.unshift(item);
    return arr1;
}

8.删除数组第一个元素
删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组

function curtail(arr) {
    var arr1 = arr.slice(0);
    arr1.shift();
    return arr1;
}

9.数组合并
合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组

function concat(arr1, arr2) {
    var arr1 = arr1.concat(arr2);
    return arr1;
}

10.添加元素
在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组

function insert(arr, item, index) {
    var arr1 = arr.slice(0);
    arr1.splice(index,0,item);
    return arr1;
}

11.计数
统计数组 arr 中值等于 item 的元素出现的次数

function count(arr, item) {
    var j=0;
    for(var i=0; i<arr.length;i++){
        if(arr[i]==item){
            j++;
        }
    }
    return j;
}

12.查找重复元素
找出数组 arr 中重复出现过的元素

function duplicates(arr) {
    var arr1=[];
    for (var i=0;i<arr.length;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]==arr[j]&& arr1.indexOf(arr[i]) == -1){ //划横线的意思是，数组arr1里arr[i]这个数没有再出现（即就这一个）。
                arr1.push(arr[i]);
            }
        }
    }
    return arr1;
}

13.求二次方
为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组

function square(arr) {
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        arr1.push(Math.pow(arr[i],2));
    }
    return arr1;
}

14.查找元素位置
在数组 arr 中，查找值与 item 相等的元素出现的所有位置

function findAllOccurrences(arr, target) {
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        if(arr[i]==target){
            arr1.push(i);
        }
    }
    return arr1;
}

15.在Javascript语言中，声明局部变量使用的都是关键字var，如果不使用var而直接声明变量，则该变量为全局变量。

16.parseInt( )函数
parseInt( ) 函数可解析一个字符串，并返回一个整数。
语法：parseInt(string,radix)
当参数 radix 的值为 0，或没有设置该参数时，parseInt() 会根据 string 来判断数字的基数。
举例，如果 string 以 “0x” 开头，parseInt() 会把 string 的其余部分解析为十六进制的整数。如果 string 以 0 开头，那么 ECMAScript v3 允许 parseInt() 的一个实现把其后的字符解析为八进制或十六进制的数字。如果 string 以 1 ~ 9 的数字开头，parseInt() 将把它解析为十进制的整数。

17.实现一个打点计时器，要求
1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
3、第一个数需要立即输出

function count(start, end) {
    var num = null;
    console.log(start);
    num = setInterval(function(){
        if(start<end){
            console.log(++start);}
    },100);
    return {
        cancel:function(){
            clearInterval(num);}}}

18.实现 fizzBuzz 函数，参数 num 与返回值的关系如下：
1、如果 num 能同时被 3 和 5 整除，返回字符串 fizzbuzz
2、如果 num 能被 3 整除，返回字符串 fizz
3、如果 num 能被 5 整除，返回字符串 buzz
4、如果参数为空或者不是 Number 类型，返回 false
5、其余情况，返回参数 num

function fizzBuzz(num) {
    if(num%3==0 && num%5==0){
        return ("fizzbuzz");
    }else if(num%3 ==0){
        return ("fizz");
    }else if(num%5 ==0){
        return ("buzz");
    }else if(num == null || typeof(num) != "number"){
        return false;
    }else{
        return num;}  
}

19.将数组 arr 中的元素作为调用函数 fn 的参数

function argsAsArray(fn, arr) {
    return fn.apply(this,arr);
}

20.将函数 fn 的执行上下文改为 obj 对象
思路：将函数 fn 的执行上下文改为 obj 对象，只需要将obj作为call或者apply的第一个参数传入即可。

function speak(fn, obj) {
    return fn.apply(obj,obj);
}

21.实现函数 functionFunction，调用之后满足如下条件：
1、返回值为一个函数 f
2、调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ‘, ’
3、所有函数的参数数量为 1，且均为 String 类型

function functionFunction(str) {
    var f = function(string){
        return str += ', '+string;
    }
    return f;
}

22.实现函数 makeClosures，调用之后满足如下条件：
1、返回一个函数数组 result，长度与 arr 相同
2、运行 result 中第 i 个函数，即 resulti，结果与 fn(arr[i]) 相同
思路：简单的描述闭包：如果在函数func内部声明函数inner，然后在函数外部调用inner，这个过程即产生了一个闭包。闭包最大的用处有两个：可以读取到函数内部的变量，让这些变量的值始终保持在内存中。

function makeClosures(arr, fn) {
    var result=[]; //声明要返回的一个数组
    for(var i=0;i<arr.length;i++){//数组result的长度和arr的长度相同
        result[i]=fun(i);//数组的值等于函数的返回值。
    }
    function fun(i){//定义一个函数fun
        return function(){ //函数返回给result的是一个匿名函数。
            return fn(arr[i]); //这个匿名函数的返回值是fn(arr[i])
        }
    }
    return result;
}

23.已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：
1、返回一个函数 result，该函数接受一个参数
2、执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致 （二次封装函数）

function partial(fn, str1, str2) {
    var result = function(str3){
        return fn.call(this,str1,str2,str3);
    }
    return result;
}

24.函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换。

function useArguments() {
    var sum =0;
    for (i=0;i<arguments.length;i++){
        sum +=arguments[i];
    }
    return sum;
} 

25.使用 apply 调用函数
实现函数 callIt，调用之后满足如下条件
1、返回的结果为调用 fn 之后的结果
2、fn 的调用参数为 callIt 的第一个参数之后的全部参数
思路：这道题的意思就是要使用apply来调用函数。那么首先声明一个数组，然后遍历数组，将其放入到新的数组args中，因为 fn 的调用参数为 callIt 的第一个参数之后的全部参数 。那么我们需要使用调用函数的方法apply()。

function callIt(fn) {
    var args=[];
    for(var i=1;i<arguments.length;i++){
        args.push(arguments[i]);
    }
    var result=fn.apply(null,args);
    return result;
}

26.二次封装函数
实现函数 partialUsingArguments，调用之后满足如下条件：
1、返回一个函数 result
2、调用 result 之后，返回的结果与调用函数 fn 的结果一致
3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数
思路：因为arguments并不是真正的数组对象，只是与数组类似而已，所以它并没有slice这个方法， 而Array.prototype.slice.call(arguments, 1)可以理解成是让arguments转换成一个数组对象，让arguments具有slice()方法。其中的1表示的是从数组的第二个元素进行截取。

function partialUsingArguments(fn) {
    var arg1 = Array.prototype.slice.call(arguments,1);
//获取partialUsingArguments这个函数的第一个参数之后的全部参数
    var result =function(){
        var arg2 = Array.prototype.slice.call(arguments,0);//获取result调用的参数
        var arg =arg1.concat(arg2);//将参数整合到一个数组中。
        return fn.apply(null,arg);
    }
    return result;
}

27.柯里化
已知fn为一个预定义函数，实现函数curryIt，调用之后满足如下条件：
1、返回一个函数a，a的 length 属性值为1（即显式声明 a 接收一个参数）
2、调用a之后，返回一个函数b, b的 length 属性值为1
3、调用b之后，返回一个函数c, c的 length 属性值为1
4、调用c之后，返回的结果与调用 fn 的返回值一致
5、fn的参数依次为函数a, b, c的调用参数
柯里化：把接受多个参数的函数变换成接受一个单一参数的函数，并且返回接受余下的参数且返回结果的新函数的技术。
思路： 简单来说，柯里化是一种允许使用部分函数参数构造函数的方式。也就是意味着，你在调用一个函数时，可以传入需要的全部参数并获得返回结果，也可以传入部分参数并的得到一个返回的函数，它需要传入的就是其余的参数。

function curryIt(fn) {
   return a=function(ra){
       return b=function(rb){
           return c=function(rc){
               return fn(ra,rb,rc);
           }
        }
    }
}

28.模块
完成函数 createModule，调用之后满足如下要求：
1、返回一个对象
2、对象的greeting属性值等于str1，name属性值等于str2
3、对象存在一个sayIt方法，该方法返回的字符串为greeting属性值 + ‘, ’ + name属性值

function createModule(str1, str2) {
    var obj = new Object();
    obj.greeting = str1;
    obj.name = str2;
    obj.sayIt = function(){return obj.greeting+', '+obj.name;};
    return obj;
}

或者

function createModule(str1, str2) {
    return {
            greeting : str1,
            name : str2,
            sayIt : function (){
                return this.greeting + ', ' + this.name;
            }
        }
  }

29.二进制转换
将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位。

function convertToBinary(num) {
    var a2 = parseInt(num).toString(2);
    if(a2.length<8){
        for(var i=0; i<8-a2.length;i++){
            a2 = "0"+a2;
        }
    }
    return a2;
}

30.属性遍历
找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)
1、返回数组，格式为 key: value
2、结果数组不要求顺序

function iterate(obj) {
    var arr=[];
    for(var key in obj){
        // hasOwnProperty用于检验obj的属性key是否是自有的（而不是原型链的）
        if(obj.hasOwnProperty(key)){
            arr.push(key+": "+obj[key]);
        }
    }
    return arr;
}

31.正则表达式
（1）判断是否包含数字
给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false

function containsNumber(str) {
    var reg = /\d/;
    return reg.test(str);
}

（2）检查重复字符串
给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false
思路：在正则表达式中，使用斜杠加数字表示引用，\1就是引用第一个分组， 将 [a-zA-Z] 作为一个分组进 行引用

function containsRepeatingLetter(str) {
     var reg=/([a-zA-Z])\1/;    //\1是对第一个括号中的内容的引用  
     return reg.test(str);  
}

（3）判断是否以元音字母结尾
给定字符串 str，检查其是否以元音字母结尾
1、元音字母包括 a，e，i，o，u，以及对应的大写
2、包含返回 true，否则返回 false
$表示匹配结尾，/i表示忽略大小写

function endsWithVowel(str) {
    var reg = /[aeiou]$/i;
    return reg.test(str);
}

（4）获取指定字符串
给定字符串 str，检查其是否包含 3 个连续的数字
1、如果包含，返回最新出现的 3 个数字的字符串
2、如果不包含，返回 false

function captureThreeNumbers(str) {
    var reg=/\d{3}/;
    var matcher=str.match(reg);
    if(matcher){
        return matcher[0];
    }
    else return false;
}

（5）判断是否符合指定格式
给定字符串 str，检查其是否符合如下格式
1、XXX-XXX-XXXX
2、其中 X 为 Number 类型

function matchesPattern(str) {
    var reg = /^\d{3}-\d{3}-\d{4}$/;
    return reg.test(str);
}

（6）判断是否符合 USD 格式
给定字符串 str，检查其是否符合美元书写格式
1、以 开始2、整数部分，从个位起，满3个数字用,分隔3、如果为小数，则小数部分长度为24、正确的格式如： 1,023,032.03 或者 2.03，错误的格式如： 3,432,12.12 或者 34,344.3思路：usd格式，以 开头，数字结尾，和小数点的转义。开头是 ，而正则表达式中$表示结尾，需要进行转义，因此开头为 ^\$。
代码如下：

function isUSD(str) {
    var reg=/^\$([1-9]\d{0,3})(,\d{3})*(\.\d{2})?$/;  
    /*1、以 $ 开始: ^$ 
    2、$之后的第一组数字可能是0,1,2,3位: [1-9]\d{0~3} 
    3、第二组开始之后的数字每组都是一个,加上三个数字：(,\d{3})*  //*表示可匹配0~n组 
    4、如果有小数部分，格式为 .加上两个数字(注意对.进行转义；并且小数为结尾部分)：(\.\d{2})?$ */  
    return reg.test(str);  
}

32.修改this指向
封装函数 f，使 f 的 this 指向指定的对象
Apply是解决this指向最经典的做法。

function bindThis(f, oTarget) {
    var func = function(){
        return f.apply(oTarget,arguments);
    }
    return func;
}

33.getCurrentPosition()用于获得用户的当前位置。

34.

<ul>
    <li>click me</li>
    <li>click me</li>
    <li>click me</li>
    <li>click me</li>
</ul>
var elements=document.getElementByTagName(‘li’);
var length = elements.length;
for(var i=0;i<length;i++){
element[i].onclick = function(){
alert(i);
}
}

答案为4,4,4,4。
解答：这里的事件，绑定的并非是i的值，而是i本身（alert里的i），所以当程序执行完，i的值变为4，去执行onclick事件时，执行alert(i) ,自动查找i，值为4，所以依次弹出4。

var elements=document.getElementsByTagName('li');
    var length=elements.length;
    for(var i=0;i<length;i++){
        elements[i].οnclick=(function(a){
            return function(){
            alert(a);
            }          
        })(i);
    }
//用此代码可以依次弹出 0，1，2，3（闭包可以“包养”外部函数变量）