js刷题ing---------1
PS:该文章题目大体趋势为由易到难，若觉得前面的太简单可从后面的看起
直角三角形
描述
请补全JavaScript代码，要求在页面上渲染出一个直角三角形，三角形换行要求使用"br"实现。三角形如下：
*
**
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
</head>
<body>
<div class='triangle'></div>
<script>
var triangle = document.querySelector('.triangle');
// 补全代码
let str=''
for(let i=0;i<3;i++){
for(let j=0;j<=i;j++){
str+='*'
}
str+='
'
}
triangle.innerHTML=str
</script>
</body>
</html>
要求以字符串的形式返回文件名扩展名，文件名参数为"filename"。
const _getExFilename = (filename) => {
// 补全代码
let index = filename.lastIndexOf('.')
return filename.slice(0,index) && index ? filename.slice(index) : ''
//文件名不能为空且必须包含‘.’
}
split()是使用指定的分隔符字符串将字符串分割成子字符串，返回一个子字符串数组;
slice（beginIndex，endIndex）方法提取某个字符串的一部分，并返回一个新的字符串，不会改变原字符串;
splice（）方法通过删除或者替换现有元素或者原地添加新元素来修改数组，并以数组形式返回被修改的内容，此方法会改变元数组
请补全JavaScript代码，要求返回参数数字的千分位分隔符字符串
1234566->1,234,567
function _comma(number) {
let negative = ''
if(number < 0) {
negative = '-'
number = Math.abs(number)
}
let array = parseInt(number).toString().split("").reverse()
let sign = 0
let commaArray = []
for(let i=0 ; i<array.length ; i++) {
if(sign === 3) {
commaArray.push(',')
sign = 0
}
commaArray.push(array[i])
sign ++
}
return negative + commaArray.reverse().join('')
}
请补全JavaScript代码，要求每当id为"input"的输入框值发生改变时触发id为"span"的标签内容同步改变。
注意：
- 必须使用DOM0级标准事件（onchange）
document.getElementById("input").onchange = function () {
document.getElementById("span").innerHTML = this.value
}
请补全JavaScript代码，要求返回一个长度为参数值并且每一项值都为参数值的数组。
注意：
- 请勿直接使用for/while
/*
通过new Array函数构造实例的时候带入参数，可以生成该参数长度的空数组
通过Array.fill函数可以将数组的每一项都改编为参数值
或Array.from函数接收两个参数即可，第一个参数为数组或对象，都表示返回数组的长度。当参数为数组时它确定了返回的新数组长度，当参数为对象时，需要添加“length”属性表明数组长度
第二个参数为一个函数，即第一个数组参数中的每一项都调用该函数
*/
const _createArray = (number) => {
// 补全代码
//return parseInt(number).toString().split("") // 此代码返回的为['1', '2', '3']
return Array(number).fill(number)
//或 return Array.from({length: number}, () => number)
}
请补全JavaScript代码，该函数接收两个参数分别为旧版本、新版本，当新版本高于旧版本时表明需要更新，返回true，否则返回false。
注意：
- 版本号格式均为"X.X.X"
- X∈[0,9]
- 当两个版本号相同时，不需要更新
const _shouldUpdate = (oldVersion, newVersion) => {
let old=oldVersion.split('.')
let new1=newVersion.split('.')
/* 一开始做法：错误 当输入为'9.0.1','9.1.0'时无法运行
for(let i=0;i<3;i++){
if(old[i] > new1[i]){
return false
}
}
return true
*/
return old < new1
}
请补全JavaScript代码，实现一个函数，要求如下：
- 根据输入的数字范围[start,end]和随机数个数"n"生成随机数
- 生成的随机数存储到数组中，返回该数组
- 返回的数组不能有相同元素
注意： - 不需要考虑"n"大于数字范围的情况
const _getUniqueNums = (start,end,n) => {
var array=[];
var num=0;
const rand=(end-start)/n;
for(let i=0;i<n;i++){
num=Math.random()*rand+i*rand+start
array.push(num)
}
return array
}
请补全JavaScript代码，根据预设代码中的数组，实现以下功能：
- 列表只展示数组中的name属性
- 实现点击"销量升序"按钮，列表内容按照销量升序重新渲染
- 实现点击"销量降序"按钮，列表内容按照销量降序重新渲染
注意： - 必须使用DOM0级标准事件（onclick）
<body>
<button class='up'>销量升序</button>
<button class='down'>销量降序</button>
<ul></ul>
<script>
var cups = [
{ type: 1, price: 100, color: 'black', sales: 3000, name: '牛客logo马克杯' },
{ type: 2, price: 40, color: 'blue', sales: 1000, name: '无盖星空杯' },
{ type: 4, price: 60, color: 'green', sales: 200, name: '老式茶杯' },
{ type: 3, price: 50, color: 'green', sales: 600, name: '欧式印花杯' }
]
var ul = document.querySelector('ul');
var upbtn = document.querySelector('.up');
var downbtn = document.querySelector('.down');
// 补全代码
const change=()=>{
var str="";
for(let i=0;i<cups.length ;i++){
str+=`${cups[i].name}`
// str=str+''+cups[i].name+' '
}
ul.innerHTML=str;
};
change();
upbtn.onclick=function(){
cups.sort(function(a,b){
return a.sales-b.sales
})
change()
};
downbtn.onclick=function(){
cups.sort(function(a,b){
return b.sales-a.sales
})
change()
}
</script>
</body>
请补全JavaScript代码，该函数接受两个参数分别为数组、索引值，要求在不改变原数组的情况下返回删除了索引项的新数组。
<script type="text/javascript">
const _delete = (array,index) => {
// 补全代码
var newArray = array.concat()
newArray.splice(index,1)
return newArray
}
</script>
请补全JavaScript代码，要求每次调用函数"closure"时会返回一个新计数器。每当调用某个计数器时会返回一个数字且该数字会累加1。
注意：
- 初次调用返回值为1
- 每个计数器所统计的数字是独立的
//考点：闭包
const closure = () => {
// 补全代码
var num=1;
return function(){
return num++
}
}
找到数组中的最大值：
var value=[1,88,7,2,3];
var max=Math.max.apply(Math,value)
请补全JavaScript代码，实现以下功能：
- 根据已有的person对象的注册时间求出距离当前时间的天数（天数向下取整）。
- 将获得的天数和person数据拼接成字符串，作为h2标签的内容。
注意：使用模板字符串进行字符串拼接，字符串最终内容如：尊贵的牛客网2级用户小丽您好，您已经注册牛客网3天啦~
<body>
<h2></h2>
<script>
var person = {
level: '2',
name: '小丽',
registTime: '2021-11-01',
}
var h2 = document.querySelector('h2');
// 补全代码
const _getDuration = registTime => {
var start = new Date(registTime)
var end = new Date()
var dates = Math.floor((end - start) / (1000 * 60 * 60 * 24))
return dates
}
h2.innerText = `尊贵的牛客网${person.level}级用户${person.name}您好，您已经注册牛客网${_getDuration(person.registTime) }天啦~`
</script>
</body>
请补全JavaScript代码，完成类的继承。要求如下：
- "Chinese"类继承于"Human"类
- “Human"类实现一个函数"getName”，返回该实例的"name"属性
- “Chinese"类构造函数有两个参数，分别为"name”、“age”
- “Chinese"类实现一个函数"getAge”，返回该实例的"age"属性
<script type="text/javascript">
class Human {
constructor(name) {
this.name = name
this.kingdom = 'animal'
this.color = ['yellow', 'white', 'brown', 'black']
}
// 补全代码
getName(){
return this.name
}
}
// 补全代码
class Chinese extends Human{
constructor(name ,age){
super(name) //super调用父类的构造函数
this.age=age
}
getAge(){
return this.age
}
}
</script>
请补全JavaScript代码，要求将字符串参数URL中的参数解析并以对象的形式返回。
示例1
输入：getParams(‘https://nowcoder.com/online?id=1&salas=1000’)
输出：{id:1, salas: 100}
const _getParams = (url) => {
// 补全代码
let start = url.indexOf('?')+1
let new1=url.slice(start).split('&')
let arr={}
for(let i=0;i<new1.length;i++){
let a=new1[i].split('=')
arr[a[0]]=a[1]
}
return arr
}
请补全JavaScript代码，要求将数组参数中的对象以总成绩(包括属性"chinese"、“math”、“english”)从高到低进行排序并返回。
const _rank = array => {
// 补全代码
return array.sort(function(a,b){
return (b.chinese+b.math+b.english)-(a.chinese+a.math+a.english)
})
return array
}
请补全JavaScript代码，该函数接受两个参数分别为字符串、子字符串，要求返回子字符串在字符串中出现的频次。
const _searchStrIndexOf = (str, target) => {
// 补全代码
return str.split(target).length-1
}
数组扁平化
请补全JavaScript代码，要求将数组参数中的多维数组扩展为一维数组并返回该数组。
注意：
- 数组参数中仅包含数组类型和数字类型
输入：[1,[2,[3,[4]]]]
输出：[1,2,3,4]
const _flatten = arr => {
// 补全代码
return arr.toString().split(',').map(item=>Number(item))
}
请补全JavaScript代码，要求根据下拉框选中的条件变换重新渲染列表中展示的商品，且只展示符合条件的商品。
注意：
- 必须使用DOM0级标准事件（onchange）
- 建议使用ES6的filter方法
<body>
<select name="" id="">
<option value="0">请选择销量范围</option>
<option value="1"><100</option>
<option value="2">100~500</option>
<option value="3">>500</option>
</select>
<ul>
<li>牛客logo马克杯</li>
<li>无盖星空杯</li>
<li>老式茶杯</li>
<li>欧式印花杯</li>
</ul>
<script>
var cups = [
{ type: 1, price: 100, color: 'black', sales: 60, name: '牛客logo马克杯' },
{ type: 2, price: 40, color: 'blue', sales: 100, name: '无盖星空杯' },
{ type: 4, price: 60, color: 'green', sales: 200, name: '老式茶杯' },
{ type: 3, price: 50, color: 'green', sales: 600, name: '欧式印花杯' }
]
var select = document.querySelector('select');
var ul = document.querySelector('ul');
// 补全代码
const change=arr=>{
var str="";
for(let i = 0;i < arr.length; i++){
str += `${arr[i].name}`
}
ul.innerHTML=str
}
change(cups)
select.onchange=function(){
var newArr=[]
console.log(select.value)
if(select.value === "1"){
newArr=cups.filter((item)=>{
return item.sales < 100
})
};
if(select.value === "2"){
newArr=cups.filter((item)=>{
return item.sales <= 500 && item.sales >= 100
})
};
if(select.value === "3"){
newArr=cups.filter((item)=>{
return item.sales > 500
})
}
change(newArr)
}
</script>
</body>
请补全JavaScript代码，要求在Number对象的原型对象上添加"_isPrime"函数，该函数判断调用的对象是否为一个质数，是则返回true，否则返回false。
Number.prototype._isPrime = function () {
let number = this.valueOf()
if(number < 2) return false
for(let i=2 ; i<=number ; i++) {
if(i === number) return true
if(number%i === 0) return false
if(number%i !== 0) continue
}
}
继承：
请补全JavaScript代码，实现以下功能：
- 给"Human"构造函数的原型对象添加"getName"方法，返回当前实例"name"属性
- 将"Chinese"构造函数继承于"Human"构造函数
- 给"Chinese"构造函数的原型对象添加"getAge"方法，返回当前实例"age"属性
/*
首先通过Human.prototype.getName给“Human”的原型添加“getName”函数
然后通过Chinese.prototype将“Chinese”的原型挂载在“Human”构造函数的实例上
修复“Chinese”的原型链
最后通过Chinese.prototype.getAge给“Chinese”的原型添加“getAge“函数
*/
function Human(name) {
this.name = name
this.kingdom = 'animal'
this.color = ['yellow', 'white', 'brown', 'black']
}
function Chinese(name,age) {
Human.call(this,name)
this.age = age
this.color = 'yellow'
}
// 补全代码
Human.prototype.getName=function(){
return this.name
}
Chinese.prototype=new Human()
Chinese.prototype.constructor=Chinese
Chinese.prototype.getAge=function(){
return this.age
}
请补全JavaScript代码，要求以Boolean的形式返回字符串参数是否符合身份证标准。
注意：
- 无需考虑地区信息、出生日期、顺序码与校验码的验证
const _isCard = number => {
// 补全代码
//(^正则表达式$) \d匹配数字
var regx = /(^\d{15}$)|(^\d{17}(\d|X|x)$)/
return regx.test(number)
}
Symbol:
请补全JavaScript代码，要求以键/值对的对象形式返回参数数组。要求如下：
- 键名的数据类型为Symbol
- 键值为当前数组项
- Symbol的描述为当前数组项
- 返回普通对象
/*
生成空对象
遍历数组
生成Symbol实例，初始化时将数组的该项带入
设置对象键名、键值
返回对象
*/
const _symbolKey = array => {
let object = {}
for(item of array) {
let key = Symbol(item)
object[key] = item
}
return object
}
Set对象
请补全JavaScript代码，要求以boolean的形式返回两个Set对象参数是否一样，是则返回true，否则返回false。
const _isSameSet = (s1, s2) => {
// 补全代码
if(s1.length != s2.length) return false
/* 可
for(let s of s1){
if(!s2.has(s)) return false;
}
*/
for(let i =0 ; i<s1.length;i++){
if(s1[i] !== s2[i]) return false
}
return true
}
Getter:
请补全JavaScript代码，完成名为"Rectangle"的矩形类。要求如下：
- 构造函数只包含两个参数，依次为"height"、“width”
- 设置Getter，当获取该对象的"area"属性时，返回该对象"height"与"width"属性的乘积
输入：new Rectangle(12,12).area
输出：144
class Rectangle {
// 补全代码
constructor(height,width){
this.height=height
this.width=width
}
get area(){
return this.height * this.width
}
}
查找两个节点的最近的一个共同父节点，可以包括节点自身
输入描述：oNode1 和 oNode2 在同一文档中，且不会为相同的节点
//取node1节点向上找父节点，判断父节点是否包含node2，
//如果不包含node2，递归继续向上找父节点
function commonParentNode(oNode1, oNode2) {
let parentNode = oNode1.parentNode
if(parentNode.contains(oNode2)){
return parentNode
}else{
parentNode = commonParentNode(parentNode, oNode2)
}
return parentNode
}
封装函数 f，使 f 的 this 指向指定的对象
修改this指向
//apply
function bindThis(f, oTarget) {
return function() {
return f.apply(oTarget, arguments)
}
}
//bind
function bindThis(f, oTarget) {
return f.bind(oTarget)
}
//call
function bindThis(f, oTarget) {
return function() {
return f.call(oTarget, ...arguments)
}
}
描述:根据包名，在指定空间中创建对象
输入描述：namespace({a: {test: 1, b: 2}}, ‘a.b.c.d’)
输出描述：{a: {test: 1, b: {c: {d: {}}}}}
/*
因为oNamespace是对象，因此o=oNamespace其实复制的是对象的引用，
因此o的改变直接影响oNamespace, 所以可以在return的时候直接返回oNamespace.
*/
function namespace(oNamespace, sPackage) {
const arr = sPackage.split('.');
let o = oNamespace;
for(let i = 0;i<arr.length ;i++) {
// 如果不是对象，则使它成为对象
if(typeof o[arr[i]] != 'object') {
o[arr[i]] = {};
}
o = o[arr[i]];
}
return oNamespace;
}
描述为 Array 对象添加一个去除重复项的方法
示例1
输入：[false, true, undefined, null, NaN, 0, 1, {}, {}, ‘a’, ‘a’, NaN]
输出：[false, true, undefined, null, NaN, 0, 1, {}, {}, ‘a’]
/*
Set数据结构类似于数组，但里面的成员都是唯一的。判断是否唯一的标准基本等同
于‘===’，唯一的区别在于，‘===’判断时NaN与NaN不相等，但Set会认为它们相等并去重。
由于Set只是类似数组，所以要用Array.from返回一个真正的数组。*/
Array.prototype.uniq = function () {
return Array.from(new Set(this))
}
找出数组 arr 中重复出现过的元素（不用考虑返回顺序）
输入：[1, 2, 4, 4, 3, 3, 1, 5, 3]
输出：[1, 3, 4]
function duplicates(arr) {
var temp=[];
arr.forEach((item)=>{
if(arr.indexOf(item) !== arr.lastIndexOf(item) && temp.indexOf(item)===-1)
temp.push(item)
})
return temp
}
实现一个打点计时器，要求
1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
3、第一个数需要立即输出
function count(start, end) {
console.log(start++)
let timer=setInterval(()=>{
if(start <= end){
//start++ 不能把++放在if内，这样当start=end时if条件仍然通过，会输出end+1
console.log(start++)
}else{
clearInterval(timer)
}
},100)
return {
cancel: function () {
clearInterval(timer)
}
}
}
请补全JavaScript代码，要求将数组参数中的数字从小到大进行排序并返回该数组。
注意：
- 数组元素仅包含数字
- 请优先使用快速排序方法
示例1
输入：_quickSort([0,-1,1,-2,2])
输出：[-2,-1,0,1,2]
/*
根据题目要求，通过快速排序实现数组参数中数字从小到大排序。快速排序的基本思想是通过分治来使一部分均比另一部分小（大）再使两部分重复该步骤而实现有序的排列。核心步骤有：
选择一个基准值（pivot）
以基准值将数组分割为两部分
递归分割之后的数组直到数组为空或只有一个元素为止
*/
const _quickSort = array => {
if(array.length <= 1) return array
var pivotIndex = Math.floor(array.length / 2)
var pivot = array.splice(pivotIndex, 1)[0]
var left = []
var right = []
for (var i=0 ; i<array.length ; i++){
if (array[i] < pivot) {
left.push(array[i])
} else {
right.push(array[i])
}
}
return _quickSort(left).concat([pivot], _quickSort(right))
}
请补全JavaScript代码，要求以数组的形式返回字符串参数的所有排列组合。
注意：
- 字符串参数中的字符无重复且仅包含小写字母
- 返回的排列组合数组不区分顺序
示例1
输入：_permute(‘abc’)
输出：[‘abc’,‘acb’,‘bac’,‘bca’,‘cab’,‘cba’]
const _permute = string => {
// 补全代码
if(string.length === 1) return [string]
const result = []
for(let s of string){
const arr = string.split('').filter(str=>str!==s)
_permute(arr.join('')).forEach(item=>{
result.push(s+item)
})
}
return result
}
请补全JavaScript代码，要求实现Object.create函数的功能且该新函数命名为"_objectCreate"。
/*
根据题目要求，实现一个仿Object.create功能的"_objectCreate"函数，该函数创建一个新对象，使用现有的对象来提供新创建的对象的proto，核心步骤有：
创建一个临时函数
将该临时函数的原型指向对象参数
返回该临时对象的实例
*/
<script type="text/javascript">
const _objectCreate = proto => {
// 补全代码
if(typeof proto !== 'object' || proto === null) return
const fn = function(){}
fn.prototype = proto
return new fn()
}
/*
或：
const _objectCreate = proto => {
let obj = new Object();
obj.__proto__ = proto;
return obj;
}
大多数情况下，__proto__可以理解为“构造器的原型”，即__proto__===constructor.prototype,但是通过 Object.create()创建的对象有可能不是， Object.create()方法创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。
即obj.__proto__=obj.constructor.prototype.
但是目前_proto_已经弃用。函数才有prototype，对象才有_proto_
*/
</script>
小菜鸡还在不断刷题更新中！快给我份好工作吧！！！