<!--
* @Description:
* @Version: 1.0
* @author: shihaixia
* @Date: 2021-08-19 11:24:30
-->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
</body>
<script>
// 根据报名，在指定空间中创建对象
// 输入描述：namespace（{a：{test：1，b:2}},'a.b.c.d'）
// 输出描述： {a:test:1,b:{c:d:{}}}}}
function namespace(oNamespace, sPackage) {
let tmpWrap = oNamespace;
sPackage.split('.').forEach(item => {
tmpWrap = tmpWrap[item] = Object.assign({}, tmpWrap[item]);
});
return oNamespace;
}
console.log(namespace({
a: {
test: 1,
b: 2
}
}, 'a.b.c.d'))
// 驼峰写法
function cssStyle2DomStyle(sName) {
return sName.replace(/^-/, '').replace(/-([a-z])/g, (_, $) => $.toUpperCase());
}
// console.log(cssStyle2DomStyle(" -webkit-border-image"))
// 给定字符串 str，检查其是否以元音字母结尾
// 1、元音字母包括 a，e，i，o，u，以及对应的大写
// 2、包含返回 true，否则返回 false
// 示例1
// 输入：'gorilla'
// 输出： true
function endsWithVowel(str) {
var newStr = "a e i o u A E I O U"
var attr = str.split("")
if (newStr.indexOf(attr[attr.length - 1]) != -1) {
return true
} else {
return false
}
}
// console.log( endsWithVowel("I KNOW KUNG FU"))
// 给定字符串 str，检查其是否包含 连续3个数字
// 1、如果包含，返回最先出现的 3 个数字的字符串
// 2、如果不包含，返回 false
// 示例1
// 输入： '9876543'
// 输出： 987
function captureThreeNumbers(str) {
var reg = str.match(/(\d{3})/)
if (reg[0]) {
return reg[0]
} else {
return false
}
}
// console.log(captureThreeNumbers("9876543"))
// 描述
// 给定字符串 str，检查其是否符合如下格式
// 1、XXX-XXX-XXXX
// 2、其中 X 为 Number 类型
// 示例1
// 输入：
// '800-555-1212'
// 输出：
// true
function matchesPattern(str) {
if (str.match(/^(\d{3}-\d{3}-\d{4})$/)) {
return true
} else {
return false
}
}
// console.log(matchesPattern('1800-555-1212'))
// 描述
// 给定字符串 str，检查其是否符合美元书写格式
// 1、以 $ 开始
// 2、整数部分，从个位起，满 3 个数字用 , 分隔
// 3、如果为小数，则小数部分长度为 2
// 4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3
// 示例1
// 输入：
// '$20,933,209.93'
// 输出：
// true
function isUSD(str) {
return /^\$\d{1,3}(,\d{3})*(\.\d{2})*$/.test(str)
}
// console.log(isUSD("$20,933,209.93.134"))
// 描述
// 给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false
// 示例1
// 输入：
// 'abc123'
// 复制
// 输出：
// true
function containsNumber(str) {
if (str.match(/(\d)/)) {
return true
} else {
return false
}
}
// console.log(containsNumber('abc123'))
//给定一个构造函数 constructor，请完成 alterObjects 方法，将 constructor 的所有实例的 greeting 属性指向给定的 greeting 变量。
// 示例1
// 输入：
// var C = function(name) {this.name = name; return this;};
// var obj1 = new C('Rebecca');
// alterObjects(C, 'What\'s up'); obj1.greeting;
// 复制
// 输出：
// What's up
function alterObjects(constructor, greeting) {
constructor.prototype.greeting = greeting
}
var C = function (name) {
this.name = name;
return this;
};
var obj1 = new C('Rebecca');
alterObjects(C, 'What\'s up');
obj1.greeting;
// 将函数 fn 的执行上下文改为 obj，返回 fn 执行后的值
// 示例1
// 输入：
// alterContext(function() {return this.greeting + ', ' + this.name + '!'; }, {name: 'Rebecca', greeting: 'Yo' })
// 复制
// 输出：
// Yo, Rebecca!
function alterContext(fn, obj) {
return fn.bind(obj)();
}
// console.log( alterContext(function() {return this.greeting + ', ' + this.name + '!'; }, {name: 'Rebecca', greeting: 'Yo' }))
// 用 JavaScript 实现斐波那契数列函数,返回第n个斐波那契数。 f(1) = 1, f(2) = 1 等
function fibonacci(n) {
if (n == 1 || n == 2) {
return 1
} else {
return fibonacci(n - 1) + fibonacci(n - 2)
}
}
// console.log(fibonacci(10))
// 统计字符串中每个字符的出现频率，返回一个 Object，key 为统计字符，value 为出现频率
// 1. 不限制 key 的顺序
// 2. 输入的字符串参数不会为空
// 3. 忽略空白字符
// 示例1
// 输入：
// 'hello world'
// 复制
// 输出：
// {h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1}
function count(str) {
var attr = str.replace(" ", "").split("")
var obj = {}
for (let i = 0; i < attr.length; i++) {
if (obj[attr[i]]) {
obj[attr[i]] += 1
} else {
obj[attr[i]] = 1
}
}
return obj
}
// console.log(count('hello world'))
// 计算给定数组 arr 中所有元素的总和
// 输入描述：
// 数组中的元素均为 Number 类型
// 示例1
// 输入：
// [ 1, 2, 3, 4 ]
// 复制
// 输出：
// 10
function sum(arr) {
var sum = 0
arr.forEach(item => {
sum += item
})
return sum
}
// console.log(sum([1, 2, 3, 4]))
// 描述
// 删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组
// 示例1
// 输入：
// [1, 2, 3, 4]
// 复制
// 输出：
// [1, 2, 3]
function truncate(arr) {
var newAttr = arr.slice(0)
return newAttr.filter((item, index) => {
return index != newAttr.length - 1
})
}
var test = [1, 2, 3, 4];
// console.log(truncate(test))
// 在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组
// 示例1
// 输入：
// [1, 2, 3, 4], 10
// 复制
// 输出：
// [10, 1, 2, 3, 4]
function prepend(arr, item) {
var newAttr = arr.slice(0)
newAttr.unshift(item)
return newAttr
}
// console.log(prepend([1, 2, 3, 4], 10))
function square(arr) {
return arr.map((cur) => {
return cur * cur
})
}
// console.log(square(
// [1, 2, 3, 4]
// ))
// 在数组 arr 中，查找值与 item 相等的元素出现的所有位置
// 示例1
// 输入：
// ['a','b','c','d','e','f','a','b','c'] 'a'
// 复制
// 输出：
// [0, 6]
function findAllOccurrences(arr, target) {
var retarr = []
arr.map((item, index) => {
if (item == target) {
retarr.push(index)
}
})
return retarr
}
// console.log(findAllOccurrences(['a', 'b', 'c', 'd', 'e', 'f', 'a', 'b', 'c'], 'a'))
// 描述
// 将函数 fn 的执行上下文改为 obj，返回 fn 执行后的值
// 示例1
// 输入：
// alterContext(function() {return this.greeting + ', ' + this.name + '!'; }, {name: 'Rebecca', greeting: 'Yo' })
// 复制
// 输出：
// Yo, Rebecca!
function alterContext(fn, obj) {
return fn.bind(obj)()
}
// console.log( alterContext(function() {return this.greeting + ', ' + this.name + '!'; }, {name: 'Rebecca', greeting: 'Yo' }))
// 输入：
// function (greeting, name, punctuation) {return greeting + ', ' + name + (punctuation || '!');}, ['Hello', 'Ellie', '!']
// 复制
// 输出：
// Hello, Ellie!
// 转换成十进制
function parse2Int(num) {
return parseInt(num, 10);
}
console.log(parse2Int("oz12px"))
// 描述
// 已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：
// 1、返回一个函数 result，该函数接受一个参数
// 2、执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致
// 示例1
// 输入：
// var sayIt = function(greeting, name, punctuation) { return greeting + ', ' + name + (punctuation || '!'); }; partial(sayIt, 'Hello', 'Ellie')('!!!');
// 复制
// 输出：
// Hello, Ellie!!!
function argsAsArray(fn, arr) {
return fn && fn(...arr);
}
// console.log(argsAsArray(function (greeting, name, punctuation) {
// return greeting + ', ' + name + (punctuation || '!');
// }, ['Hello', 'Ellie', '!']))
// 未知参数的和
function useArguments() {
var sum = 0
for (let i = 0; i < arguments.length; i++) {
sum += arguments[i]
}
return sum
}
// console.log(useArguments(1, 2, 3, 4))
// 删除相同元素
function remove(arr, item) {
var newArr = arr.filter(itemData => {
return itemData != item
})
return newArr
}
console.log(remove(
[1, 2, 3, 4, 2], 2
))
// 找出数组 arr 中重复出现过的元素（不用考虑返回顺序）
function duplicates(arr) {
var temp = [];
arr.forEach(function (elem) {
if (arr.indexOf(elem) != arr.lastIndexOf(elem) && temp.indexOf(elem) == -1) {
temp.push(elem);
}
});
return temp;
}
// console.log(duplicates([1, 2, 4, 4, 3, 3, 1, 5, 3]))
// 实现一个打点计时器，要求
// 1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
// 2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
// 3、第一个数需要立即输出
function count(start, end) {
console.log(start); //立即输出第一个数
var timer = setInterval(() => {
if (start < end) { //从start到end
console.log(++start); //每次数字增幅为1
} else {
clearInterval(timer);
}
}, 100) // 100毫秒执行一次
return { //返回一个包含cancel的方法
cancel() {
clearInterval(timer);
}
}
}
// 获取数字 num 二进制形式第 bit 位的值。 注意：
// 1、 bit 从 1 开始
// 2、 返回 0 或 1
// 3、 举例： 2 的二进制为 10， 第 1 位为 0， 第 2 位为 1
function valueAtBit(num, bit) {
return num.toString(2).split("").reverse()[bit - 1]
}
// console.log(valueAtBit(128, 8))
// 实现 fizzBuzz 函数， 参数 num 与返回值的关系如下：
// 1、 如果 num 能同时被 3 和 5 整除， 返回字符串 fizzbuzz
// 2、 如果 num 能被 3 整除， 返回字符串 fizz
// 3、 如果 num 能被 5 整除， 返回字符串 buzz
// 4、 如果参数为空或者不是 Number 类型， 返回 false
// 5、 其余情况， 返回参数 num
function fizzBuzz(num) {
let str = ""
if (!num || typeof num != 'number') {
return false
} else if (num % 3 == 0 && num % 5 == 0) {
str = "fizzbuzz"
} else if (num % 3 == 0) {
str = "fizz"
} else if (num % 5 == 0) {
str = "buzz"
} else {
str = num
}
return str
}
// console.log(fizzBuzz("foo"))
// 将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位。
function convertToBinary(num) {
let res = num.toString(2);
return res.length < 8 ? new Array(8 - res.length).fill(0).join('') + res : res;
}
// console.log(convertToBinary(2))
// 实现函数 makeClosures， 调用之后满足如下条件：
// 1、 返回一个函数数组 result， 长度与 arr 相同
// 2、 运行 result 中第 i 个函数， 即 result[i]()， 结果与 fn(arr[i]) 相同'
function makeClosures(arr, fn) {
}
console.log(makeClosures([1, 2, 3], function (x) {
return x * x;
}))
// 找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)
// 1、 返回数组， 格式为 key: value
// 2、 结果数组不要求顺序
// 示例1
// 输入：
// var C = function () {
// this.foo = 'bar';
// this.baz = 'bim';
// };
// C.prototype.bop = 'bip';
// iterate(new C());
// 复制
// 输出：
// ["foo: bar", "baz: bim"]
function iterate(obj) {
console.log(obj)
let arr = [];
Object.keys(obj).forEach(key => {
arr.push(key + ": " + obj[key])
})
return arr;
}
var C = function () {
this.foo = 'bar';
this.baz = 'bim';
};
C.prototype.bop = 'bip';
console.log(iterate(new C()));
</script>
</html>
05-15
187
187
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
