1. 乘法表
for (var i = 1; i <= 9; i++) { // 外层循环决定行的数量
for (var j = 1; j <= i; j++) { // 内层循环决定列的数量
document.write(j + "*" + i + "=" + j * i + "  ");
}
document.write("<br>"); // 添加换行
}
2.传递任意字符串,将该字符串翻转并返回
var str = 'what is a arguments?';
function reverseStr(newStr) {
var strOne = ''; //定义空字符串
for (var i = newStr.length - 1; i >= 0; i--) { //遍历形参(传递过来的字符串)
strOne += newStr[i];
}
//返回倒序拼接后的字符串
return strOne;
}
console.log(reverseStr(str));
3. 封装将字符串中的数字全部相加并返回
var str = 'a4b2c7d4xx8yy6';
function strNum(newStr) {
var sum = 0; //定义空容器
for (var i = 0; i < newStr.length; i++) { //遍历形参
if (newStr[i] >= 1 && newStr[i] <= 9) { //判断当前项是否是数字
sum += +newStr[i]; //将该项转为数值后,累加在sum中
}
if (!isNaN(newStr[i])) { //第二种判断方法
sum += +newStr[i];
}
}
return sum;
}
console.log(strNum(str));
4.封装一个函数,将传递过来的字符串中的所有数字拼接上一对小括号(),非数字不拼接括号,将最终的字符串返回
var str = 'a4b2c 7d4xx8yy6'; // ==> a(4)b(2)c(7)d(4)xx(8)yy(6)
function addBracket(newStr){
var strOne = '';
for(var i = 0; i < newStr.length;i++){ //遍历字符串
if(!isNaN(newStr[i]) && newStr[i] != ' '){ //判断是否为数字
strOne += '(' + newStr[i] + ')';
}else{ //如果不是数字,则原样拼接
strOne += newStr[i];
}
}
return strOne;
}
console.log(addBracket(str));
5. 封装indexOf方法
var str = 'catmatqatxat';
function indexof(newStr, val) {
for (var i = 0; i < newStr.length; i++) {
if (val == newStr[i]) { //判断val 是否和当前项(newStr[i])是否相等
return i;
}
}
return -1; //循环结束如果函数没有结束,则意味着没有匹配成功,返回-1
}
console.log(indexof(str, 'a'));
6. var str='a2b4admin3'字符的每个数字都乘2 ,成为'a4b8admin6'
var str = 'a2b4admin3';
function doubleStr(newStr) {
var strOne = '';
for (var i = 0; i < newStr.length; i++) {
if (!isNaN(newStr[i]) && newStr[i] != ' ') { //判断当前值是否为数字
strOne += newStr[i] * 2;
} else { //否则,原样拼接
strOne += newStr[i];
}
}
return strOne;
}
console.log(doubleStr(str));
6.var str='abc' 让字符串重复3遍，成为 str='abcabcabc'
var str = 'abc';
function againStr(newStr, num) {
var strOne = '';
for (var i = 1; i <= num; i++) {
strOne += newStr;
}
return strOne;
}
console.log(againStr(str, 10));
7.求数组中最大值和最小值
var arr = [4,-1,-3,6,23,21,-5];
function MaxMinNum(newArr){
var max = 0, //求最大值:初值设的足够小
min = 9999999999; //求最小值:初值设的足够大
for(var i = 0; i < newArr.length;i++){
if(max < newArr[i]){ //判断max值是否小于当前项
max = newArr[i]; //覆盖max
}
if(min > newArr[i]){ //判断min值是否大于当前项
min = newArr[i]; //覆盖min
}
}
return '最大值:' + max + ',最小值:' + min
}
console.log(MaxMinNum(arr));
8.封装获取n--m之间的随机整数
function randomNum(n,m){
return Math.floor(Math.random() * ( m - n + 1) + n);
}
console.log(randomNum(1,2));
9.转驼峰
var str = 'get-elements-by-tag-name'; //getElementsByTagName
function fn(newStr){
var arr = newStr.split('-'),
strOne = arr[0];
//从第二项开始遍历数组
for(var i = 1; i < arr.length; i++){
strOne += arr[i][0].toUpperCase() + arr[i].slice(1);
}
return strOne;
}
console.log(fn(str));
var str = 'i-am-want-to-sleep';
function fn(str){
var arr = str.split('-'), //以'-'做分隔符转数组
newStr = arr[0]; //'i'
//从第二项开始遍历
for(var i = 1; i < arr.length;i++){
newStr += arr[i].charAt(0).toUpperCase() + arr[i].slice(1);
}
return newStr;
}
console.log(fn(str));
10.去重 var arr = [1,4,5,4,5,1,2,3,2,3];
var arr = [1, 4, 5, 4, 5, 1, 2, 3, 2, 3];
function removeAgain(arr) {
//定义新数组用来保存不重复的数组项
var newArr = [];
for (var i = 0; i < arr.length; i++) { //遍历原数组
//判断当前项是否出现在新数组中
if (newArr.indexOf(arr[i]) == -1) {
newArr.push(arr[i]);
}
}
return newArr;
}
console.log(removeAgain(arr));
11.编写一个函数 unique(arr)，返回一个去除数组内重复的元素的数组（不能使用indexof方法）
var arr = [1,1,2,2,3,3,3,4,4,4,4,5,5,5,5,5];
function index(newArr,val){ //arr接受保存不重复值的数组,val接受当前要判断的项
for(var i = 0; i <= newArr.length;i++){
//判断当前值val是否出现在了arr中
if(newArr[i] === val){
return false;
}
}
return true;
}
function unique(arr){
var newArr = []; //定义保存不重复项的数组
for(var i = 0; i < arr.length;i++){ //遍历初始数组
if(index(newArr,arr[i])){
newArr.push(arr[i]);
}
}
return newArr;
}
console.log(unique(arr));
12.封装函数,10到100的十位随机数并升序排序
function randomNum() {
var newArr = [];
while (newArr.length < 10) {
var num = ranDom(10, 100);
if (newArr.indexOf(num) == -1) {
newArr.push(num);
}
}
return newArr.sort(function(x, y) {
return x - y
});
}
function ranDom(n, m) {
return Math.floor(Math.random() * (m - n + 1) + n);
}
console.log(randomNum());
13.删除数组中指定的值
var arr = ["1705E","22","34305","cs","dw",100,35,28];
function removeVal(arr,val){ //arr:接收操作的数组 val:接受要删除的项
for(var i = 0; i < arr.length;i++){
if(arr[i] === val){ //判断数组的当前项是否和val相等
arr.splice(i,1);
return arr;
}
}
}
console.log(removeVal(arr,'dw'));
14.封装toFixed方法
var Tofixed = function(num,len){//通过函数表达式声明ToFixed函数，并定义形参
if(len === undefined){//是否省略了len,用0来代替保留的小数位数
return parseInt(num);
}else if(len < 0 || len > 20){//判断len是否在0~20之间，如果超出范围，则报错
alert('超出范围');
}else{
var str = String(num); //将数值转为字符串
if(str.indexOf('.') != -1){
var qian = str.slice(0,str.indexOf('.'));//截取小数点前的部分
var hou = str.slice(str.indexOf('.') + 1);//截取小数点后的部分
if(hou.length < len){//判断num小数个数是否小于len，如果小于不够部分则补零
for(var i = 1; i <= len - hou.length;i++){
str += '0'; //将0拼接到原数字上
}
return str;
}else if(hou.length > len){//如果num小数个数大于len，则按len指定的位置截取小数
return qian + '.' + hou.slice(0,len); //7、将截取后的小数与整数部分拼接并输出
}else{
return num;
}
}
}
}
console.log(Tofixed(12,3));
function Tofixed(num,len){ var str = String(num); if(len === undefined || len === 0){ return parseInt(num); //返回整数部分 }else{ if(str.indexOf('.') == -1){ for(var i = 1; i <= len;i++){ if(i == 1){ str += '.0'; }else{ str += '0'; } } return str; } else{ var first = str.slice(0,str.indexOf('.')), //截取.之前的内容 last = str.slice(str.indexOf('.') + 1); //截取.之后的内容 if(len === last.length){//如果需要保存的位数和当前位数一致 则原样返回 return num; }else if(len > last.length){//如果要保存的位数5大于当位数3则补差值(5-3)个0 var newLen = len - last.length; //计算差值 for(var i = 1; i <= newLen;i++){ if(last.length == 0){ last += '.0'; }else{ last += '0'; } } return first + '.' + last; }else{ return first + '.' + last.s lice(0,len); } } }}
var num = 12.23; console.log(Tofixed(1.234,0));
15. 编写一个函数 spacify，返回一个每个字符中添加空格的字符。
spacify("ScriptOJ") // => "S c r i p t O J"
function spacify(str){
var newStr = '';
//遍历字符串
for(var i = 0; i < str.length;i++){
newStr += str[i] + ' ';
}
return newStr;
}
console.log(spacify('woxiangshuijiao'));
16.检查一个字符串(str)是否以指定的字符串(target)结尾
function confirmEnding(str,val){
var arr = [];
if(str.indexOf(' ') != -1){
arr = str.split(' '); //如果有空格 ==> 通过空格转数组
}else{
arr = str.split(''); //如果没有空格 ==> 通过空字符串转数组
}
if(arr[arr.length - 1] === val){
return true;
}
return false;
}
console.log(confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "frozen"));
console.log(confirmEnding("Bastian", "t"));
17.首字母大写,其余全部小写
确保字符串的每个单词首字母都大写，其余部分小写。（eg:titleCase("I'm a little tea pot") 应该返回 "I'm A Little Tea Pot". titleCase("sHoRt AnD sToUt") 应该返回 "Short And Stout".） 会每天写一个 主要也是没有事件，如果有更简单的方法可以分享一下，如有好的知识点望大家也分享一下谢谢，小弟感激不尽！
function titleCase(str) {
var arr = str.toLowerCase().split(' '),
newStr = '';
//遍历数组
for (var i = 0; i < arr.length; i++) {
//将当前项的第一
arr[i].slice(1) + ' ';
}
return newStr;
}
console.log(titleCase('Im a little tea pot'));
console.log(titleCase('sHoRt AnD sToUt'));
18.金克斯的迫击炮 第一种
function destroyer(arr){
for(var i = 1; i < arguments.length;i++){
for(var j = arr.length - 1; j >= 0;j--){
if(arguments[i] === arr[j]){ //判断当前arugmnets项是否和arr项相等,如果相等则把arr项删除
arr.splice(j,1);
}
}
}
return arr;
}
console.log(destroyer([1,2,2,3,1], 2, 3));// 应该返回 [1, 1].
console.log(destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3));// 应该返回 [1, 5, 1]
金克斯的迫击炮 第二种
function destroyer(arr,a,b){
var newArr = [];
for(var i = 0; i < arr.length;i++){
if(arr[i] !== a && arr[i] !== b){ //判断当前项是否不等于a也不等于b
newArr.push(arr[i]);
}
}
return newArr;
}
console.log(destroyer([1,2,2,3,1],2,3));
var arr = [2,3,1];
arr.sort(function(x,y){return x - y}) == > [1,2,3]
19.找出最长单词在句子中找出最长的单词，并返回它的长度。函数的返回值应该是一个数字。
var str = 'Walking on water and developing software';
function longest(str){
var arr = str.split(' '),
count = 0;
//遍历数组
for(var i = 0; i < arr.length;i++){
if(count < arr[i].length){
count = arr[i].length;
}
}
return count;
}
console.log(longest(str));
20.如果数组第一个字符串元素包含了第二个字符串元素的所有字符，函数返回true。
举例，["hello", "Hello"]应该返回true，因为在忽略大小写的情况下，第二个字符串的所有字符都可以在第一个字符串找到。 ["hello", "hey"]应该返回false，因为字符串"hello"并不包含字符"y"。
var arr = ['hello', 'Hello'];
function searchAgain(arr) {
arr[0] = arr[0].toLowerCase(); //全部转小写
arr[1] = arr[1].toLowerCase();
for (var i = 0; i < arr[1].length; i++) { //遍历第二个数组项
if (arr[0].indexOf(arr[1][i]) == -1) { //判断第二个数组项中的数是否出现在了第一项里
return false;
}
}
return true;
}
console.log(searchAgain(arr));
console.log(searchAgain(['QwrADz', 'qWe']));
21. 在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组
输入 [1, 2, 3, 4], 'z', 2
输出 [1, 2, 'z', 3, 4]
function addNode(arr,val,index){
var newArr = [];
//遍历原数组
for(var i = 0; i < arr.length;i++){
if(i == index){ //判断是否为要添加的下标
newArr.push(val);
}
newArr.push(arr[i]);//[1,2,'z',3,4]
}
return newArr;
}
console.log(addNode([1,2,3,4],'z',2));
22.先给数组排序，然后找到指定的值在数组的位置，最后返回位置对应的索引。
举例：where([1,2,3,4], 1.5) 应该返回1。因为1.5插入到数组[1,2,3,4]后变成[1,1.5,2,3,4],而1.5对应的索引值就是1。
同理，where([20,3,5], 19) 应该返回 2。因为数组会先排序为 [3,5,20]，19插入到数组[3,5,20]后变成[3,5,19,20],而19对应的索引值就是2。
function where(arr,val){
arr.sort(function(x,y){return x - y ;})
console.log(arr)
//遍历排序后的arr
for(var i = 0; i < arr.length;i++){
if(val <= arr[i]){
return i;
}
}
}
console.log(where([1,3,2,4],2.5)); //[1,2,3,4] 2.5
23.查找字符串中出现次数最多的字符和次数 第一种
var str = 'baacqabbccbcbc';
function searchStr(str) {
var max = 0, //max记录出现最多的次数
val = ''; //val记录出现最多的字符
for (var i = 0; i < str.length; i++) {
//字符串转数组的项数 == 字符在字符串出现的次数 + 1;
var arr = str.split(str[i]);
if (max < arr.length - 1) {
max = arr.length - 1;
val = str[i];
}
}
return '出现最多的是' + val + ',出现了' + max + '次';
}
console.log(searchStr(str));
var str = 'abbccc';
function searchZf(str){
var val = '',
count = 0;
for(var i = 0; i < str.length;i++){// 遍历字符串
var arr = str.split(str[i]); //将字符串通过当前项转为数组
if(count < arr.length - 1){
val = str[i];
count = arr.length - 1;
}
}
return '出现最多的是:' + val + '出现了:' + count + '次';
}
//split(分隔符)方法 ==> 分割后的数组长度 = 分隔符在字符串中出现的次数 + 1;
console.log(searchZf(str));
查找字符串中出现次数最多的字符和次数 第二种
var str = 'abbccc',
max = 0,
val = '';
for(var i = 0; i < str.length;i++){
var count = 0;
for(var j = 0; j < str.length;j++){
if(str[i] === str[j]){
count++;
}
}
if(max < count){
max = count;
val = str[i];
}
}
console.log(max,val)
24.参数：数组,二维数组每一项的长度
function test(arr, n) {
var arr2 = [].concat(arr); // 得到一个新数组，为了不影响传入的数组
var newArr = []; // 用于存储新的二维数组
while (arr2.length) {
newArr.push(arr2.splice(0, n)); // arr2.splice(0, n)的返回值是一个数组，将它添加到新数组中
}
return newArr;
}
var arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'];
var c = test(arr, 2);
// console.log(c);
var d = test(arr, 3);
console.log(d);
25.封装一个format 函数,传入一个长度相等的一维数组组成的二维数组作为参数，在函数内部按照下面实例对该二维数组进行格式化，最后将格式化的结果返出来。
1）例：定义一个二维数组source1=[[1,2,3],[4,5,6],[7,8,9]],执行format(source1)的返回结果是：[[1,4,7],[2,5,8],[3,6,9]]
2）例：定义一个二维数组source2=[[1,2],[3,4],[5,6]],执行format（source2）的返回结果是：[[1,3,5],[2,4,6]]
3）例：定义一个二维数组source3=[[1,2,3,4],[5,6,7,8]]执行format（source3）的返回结果是：[[1,5],[2,6],[3,7],[4,8]]
var format = function(arr) {
var len = arr[0].length, //获取新数组的长度
newArr = [];
for (var i = 0; i < len; i++) {
var arrOne = []; //定义空数组组 ==> 保存每一个小数组中的项
for (var j = 0; j < arr.length; j++) {
arrOne.push(arr[j][i]);
}
newArr.push(arrOne);
}
return newArr;
}
var arr = [
[1, 2],
[3, 4],
[5, 6]
];
// [[1,3,5],[2,4,6]]
console.log(format([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]));
26.封装一个函数equal(a1,a2),传入两个一维数组，判断两个数组是否包含相同的元素，如果相等，函数的返回值为true，不相等，函数的返回值为false
1）例：arr1 = ['a', 'b'] arr2 =['b', 'a'],equal(arr1,arr2)的返回值为true
2）例：arr3 = [2,3] arr4=[3,4],equal(arr3,arr4)的返回值为false
function equal(a1,a2){
for(var i = 0; i < a1.length;i++){ //遍历a1循环
if(a2.indexOf(a1[i]) == -1){
return false;
}
}
return true;
}
var arr1 = ['a','b'],
arr2 = ['b','a'];
console.log(equal(arr1,arr2))
27.编程实现，往数组里插入一个元素
var arr = ['马上','月考','啦','哈哈'];
function insert(arr,index,val){
for(var i = arr.length - 1; i >= index;i--){
arr[i + 1] = arr[i];
}
arr[index] = val;
return arr;
}
console.log(insert(arr,0,'请求'));
['马上','月考','嘻嘻','啦','哈哈']
28.冒泡排序 ==> 封装sort方法
var arr = [3,4,1,5,2];
function fn(){
var temp; //定义中间变量
//外循环控制比较的轮数 = (元素个数 - 1) 轮
for(var i = 1; i <= arr.length - 1;i++){
//内循环控制每轮比较的次数 = 元素个数 - 当前轮数
for(var j = 0;j < arr.length - i;j++){
if(arr[j] > arr[j + 1]){ // > 升序排序 < 降序排序
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
console.log(fn(arr));
29.10到100的十位随机数并排序(不能重复)
function randomNum(){
var arr = [];
while(arr.length < 10){ //判断arr中的值是否小于10
var val = ranDom(10,100); //获取10-100之间的随机数
if(arr.indexOf(val) == -1){
arr.push(val);
}
}
return arr.sort(function(x,y){return x - y })
}
//封装获取随机数的方法
function ranDom(n,m){ // n接收最小值 m接收最大值
return Math.floor(Math.random() * (m - n + 1) + n);
}
console.log(randomNum());
30.千分符
var num = 222191;
function fn(num) {
var str = String(num); //先将数字转为字符串
var index = str.length % 3; //0
var newStr = str.substr(0, index); //先截取前面的部分
for (var i = index; i < str.length; i += 3) {
if (i == 0) {
newStr += str.substr(i, 3);
} else {
newStr += ',' + str.substr(i, 3);
}
}
return newStr;
}
console.log(fn(num));
31.判断字符串是否对称
var str1="23421";
function isduic(str){
for(var i = 0; i < str.length/2; i++){
if(str[i] !== str[str.length - 1 - i]){
return '不对称';
}
}
return '对称';
}
console.log(isduic(str1));
32.参数：数组，二维数组每一项的长度
function test(arr, n) {
var newArr = []; // 用于存储新的二维数组
while (arr.length) { //1
newArr.push(arr.splice(0, n)); // arr2.splice(0, n)的返回值是一个数组，将它添加到新数组中
}
return newArr;
}
var arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'];
console.log(test(arr, 3))
newArr = [ ['a', 'b', 'c'],
['d', 'e', 'f'],
['g', 'h', 'i'],
['j']
]
33.!!!编写一个方法将一维数组转化成二维数组（将数组中的重复项合并到一个新数组，最后拼接成一个二维数组）==> 非常重要!!!!!!!
经过转换后的结果
[ [2,2,2], [1,1], [3,3,3,3], [4,4] ]
function test(arr) {
arr.sort(); // 排序
var newArr = []; // 存储二维数组
var val = arr[0]; //获取数组中的第一个值
for (var i = 0; i < arr.length; i++) { //遍历arr数组
if (val !== arr[i]) {
//更新val值
val = arr[i];
newArr.push(arr.splice(0, i));
i = 0; //把i重置为0
}
}
newArr.push(arr) //把最后一组数 添加到newArr的队尾
return newArr;
}
//[[1,1],[2,2,2],[3,3,3,3],[4,4]]
var arr = [2, 1, 2, 3, 2, 3, 4, 3, 3, 4, 1];
var c = test(arr);
console.log(c);
34.1．封装一个numberSort(nList)函数，实现如下功能：nList是个数字串，例如1,4,5,23,2,17,24,897。请把这串数字转为数组后按照中间高两边低进行排序，最后的结果是["1", " 4", " 5", " 23", " 897", " 24", " 17", " 2"]，请注意左右翼数据数据的平衡性（左右两边的数个数一致）
function numberSort(nList){
//将数字串nList转为数组
var arr = nList.split(','),
firstArr = [],
lastArr = [];
if(arr.length % 2){//正确的判断数组长度是否为偶数
arr.sort(function(x,y){return x - y}); //升序排序
var val = arr.splice(arr.length - 1,1)[0]; //删除最大值
firstArr = arr.slice(0,arr.length/2); //获取前面数组
lastArr = arr.slice(arr.length/2); //获取后面数组
firstArr.sort(function(x,y){return x - y}); //前一个升序排序
lastArr.sort(function(x,y){return y - x}); //后一个降序排序
return firstArr.concat(val,lastArr);
}else{//偶数
firstArr = arr.slice(0,arr.length/2); //获取前面数组
lastArr = arr.slice(arr.length/2); //获取后面数组
firstArr.sort(function(x,y){return x - y}); //前一个升序排序
lastArr.sort(function(x,y){return y - x}); //后一个降序排序
return firstArr.concat(lastArr);
}
}
console.log(numberSort('1,23,6,56,213,321,12,31,2,122'));
35.1．完成 isAnagram，接受两个字符串作为参数，返回true 或者 false 表示这两个字符串是否同字母异序。
同字母异序指的是两个字符串字母种类和字母的数量相同，但是顺序可能不同
例如：
function isAnagram(arrOne,arrTwo){
if(arrOne.length == arrTwo.length){
for(var i = 0; i < arrOne.length;i++){
if(arrTwo.indexOf(arrOne[i]) == -1){
return false;
}
}
return true;
}
}
console.log(isAnagram("anagram", "nagaram")); // return true.
console.log(isAnagram("rat", "car")); // return false.
36.2．完成getSum(),该函数接收1个数组作为参数，返回该数组中所有非重复数字的和；
getSum([undefined,"23year",19,"097",1,"hello",null,1]) // return 20
function getSum(arr){
var newArr = [],
sum = 0;
for(var i = 0; i < arr.length;i++){ //去重
if(newArr.indexOf(arr[i]) == -1){
newArr.push(arr[i]);
}
}
//遍历新数组,将该数组中的所有数字相加
for(var j = 0; j < newArr.length;j++){
if(typeof newArr[j] == 'number'){
sum += newArr[j];
}
}
return sum;
}
console.log(getSum([undefined,"23year",19,"097",1,"hello",null,1]))
37.3．完成uniqueNums(),该函数接收1个参数n（一个不大于31的整数），其返回值是一个数组，该数组内是 n 个随机且不重复的整数，且整数取值范围是 [2, 32]；
function uniqueNums(n){
var arr = [];
while(arr.length < n){ //n == 3
var num = randomNum(2,32); //获取随机数
if(arr.indexOf(num) == -1){ //判断当前的随机数是否出现在了arr中
arr.push(num);
}
}
return arr;
}
//封装获取随机数的函数
function randomNum(n,m){
return Math.floor(Math.random() * ( m - n + 1) + n);
}
console.log(uniqueNums(20)); // return [19,7,10]
38.提取参数
var url = 'www.quna.com/kdsadjksd?data_in=2019-5-1&data_out=2019-5-4&cityid=02&name=八维国际';
function searchInfor(str,val){
//1.截取有效字符串
//2.以'&'做分隔符转数组
var arr = url.slice(url.indexOf('?') + 1).split('&');
//遍历arr数组
for(var i = 0; i < arr.length;i++){
//用val和每个数组项'='前的内容做比较
if(val == arr[i].slice(0,arr[i].indexOf('='))){
return arr[i].slice(arr[i].indexOf('=') + 1);
}
}
}
console.log(searchInfor(url,'cityid'));
searchInfor(url,'data_in');
searchInfor(url,'cityid');
39.2. 封装一个函数searchResult(),根据传入的数据及条件，输出符合条件的人名，最终得到是一个数组。
(2) searchResult(stus,’女’,’大一’)根据数据去查询，将符合条件女且大一的学生姓名放到一个数组中返回
var stus = [['小A', '女', 21, '大一'],
['小B', '男', 23, '大三'],
['小C', '男', 24, '大四'],
['小D', '女', 21, '大一'],
['小E', '女', 22, '大四'],
['小F', '男', 21, '大一'],
['小G', '女', 22, '大二'],
['小H', '女', 20, '大三'],
['小I', '女', 20, '大一'],
['小J', '男', 20, '大三']];
function searchResult(arr,sex,glass){
var newArr = [];
for(var i = 0; i < arr.length;i++){
if(arr[i].indexOf(sex) != -1 && arr[i].indexOf(glass) != -1){
newArr.push(arr[i][0]);
}
}
return newArr;
}
console.log(searchResult(stus,'大一','女'));
40.封装一个函数color(),根据传入的参数来实现获取或设置背景或字体颜色。
function color(node,sty,styleval){ if(styleval === undefined){ //判断第三个参数是否接收到值 return node.style[sty]; }else{ node.style[sty] = styleval; //设置样式 }} var box = document.getElementById('box'); console.log(color(box,'background')); //用于获取box的背景色 console.log(color(box,'background-color','black'));//用于设置box的背景色为红色
41.二维数组转一维数组
function erBianYi(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
for (var j = 0; j < arr[i].length; j++) {
newArr.push(arr[i][j]);
}
}
return newArr;
}
var arr = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
];
console.log(erBianYi(arr));
42.n天之后星期几
function nDay(n){
var date = new Date(); //创建日期对象
date.setDate(date.getDate() + n); //设置日期
return date.getDay(); //返回星期
}
console.log(nDay(3));
43.封装一个方法,实现求任意多个数的平均值
function sum(){
var Sum = 0;
for(var i = 0; i < arguments.length;i++){
Sum += arguments[i];
}
return Sum / arguments.length;
}
console.log(sum(2,3,4));
44.随机从数组中取出三个不同的值。var arr = [1,2,3,4,5,6,7,8,9]
var arr = [1,2,3,4,5,6,7,8,9];
function randomNum(arr){
var newArr = [];
while(newArr.length < 3){
var num = arr[Math.floor(Math.random() * arr.length)]
if(newArr.indexOf(num) == -1){
newArr.push(num);
}
}
return newArr;
}
console.log(randomNum(arr));
var arr = [1,2,3,4,5,6,7,8,9]; //数组不重复的时候
function randomNum(arr){
var newArr = [];
while(newArr.length <3){
var num = arr[Math.floor(Math.random() * arr.length)];
newArr.push(num);
arr.splice(arr.indexOf(num),1);
}
return newArr;
}
console.log(randomNum(arr));
function fn(n){
arr = ['零 ','一','二','三','四','五','六','七','八','九'];
return arr[n];
}
function newFn(num){
if(num < 10){
return fn(num);
}else if(num % 10 == 0){
return fn(Math.floor(num /10)) + '十';
}else{
return fn(Math.floor(num /10)) + '十' + fn(num % 10);
}
}
console.log(newFn(88));
function fn(str) {
return str
}
console.log(fn("abc"))
