fn

题目链接： https://nanti.jisuanke.com/t/A1541 题意：给你一个L，求不小于L的最小的N，使的存在正整数m满足2m(m+1)=n(n+1) 分析：这题一看就没什么思路，就索性直接根据2m(m+1)=n(n+1)打表，来找规律，可以发现前面几项就是3,20,119,696,4059 尝试一下找规律，如果自己不会找就直接用求线性递推式系数公式来暴力枚举，成功得到递推公式是f(n)=6f(n-1)-f(n-2)+2; import java.io.*; import java.util.*; import java.math.*; public class Main { public static void main(String args[]) { Scanner cin = new Scanner(System.in); int T=cin.nextInt(); BigInteger[] fn=new BigInteger [1500]; BigInteger two=new BigInteger("2"); BigInteger six=new BigInteger("6"); BigInteger L; fn[1]=new BigInteger("3");fn[2]=new BigInteger("20"); for(int i=3;i<=1200

　　　js面向对象 　　　　 类：具有相同特征的一些对象的集合； 　　　　对象：具体某一个事物了，都可以叫对象； 　　　　类：通过function定义的类，所以js里类的本质为函数； 　　　　类的标志：首字母大写（函数名 ）　　函数内部使用this　　调用函数使用new关键字； 　　　　1.类和函数天生有prototype和__proto__两个属性，prototype又是一个对象，天生有一个constructor的属性，属性值函数或类本身； 　　　　2.普通对象：天生有一个__proto__的属性，这个属性又是一个对象，指向他的父类； 　　　　引用关系： 　　　　fn.prototype.init=function(){} 　　　　fn.prototype={ init:function(){} } 　　　　他们的区别？ 　　　　　　前者不会改变原有引用关系，后者会改变原有的引用关系； 　　　　　　注意：每个变量只能有一个地址 　　　　　　拷贝：浅拷贝，深拷贝； 　php的面向对象 　　类的创建：class创建； 　　　　class Person{} 　　对象的创建：使用new关键字： 　　　　$p:new Person(); (如果里面没有参数，可以不加括号)； 　　成员的添加：需要3个修饰符：public　　protected　　private 　　public

在开发 vue 的时候，我们可以使用 watch 和 computed 很方便的检测数据的变化，从而做出相应的改变，但是在小程序里，只能在数据改变时手动触发 this.setData() ，那么如何给小程序也加上这两个功能呢？ 我们知道在 vue 里是通过 Object.defineProperty 来实现数据变化检测的，给该变量的 setter 里注入所有的绑定操作，就可以在该变量变化时带动其它数据的变化。那么是不是可以把这种方法运用在小程序上呢？ 实际上，在小程序里实现要比 vue 里简单，应为对于 data 里对象来说，vue 要递归的绑定对象里的每一个变量，使之响应式化。但是在微信小程序里，不管是对于对象还是基本类型，只能通过 this.setData() 来改变，这样我们只需检测 data 里面的 key 值的变化，而不用检测 key 值里面的 key 。 先上测试代码 <view>{{ test.a }}</view> <view>{{ test1 }}</view> <view>{{ test2 }}</view> <view>{{ test3 }}</view> <button bindtap="changeTest">change</button> const { watch, computed } = require('./vuefy.js') Page({

1.this指向它的调用对象 function getA(){ 　　var a = 1; 　　console.log(this); //window 　　console.log(this.a); //undefined } getA(); //等价于window.getA() 　 var getA={ 　　a:"1", 　　fn:function(){ 　　　　console.log(this.a) //1 　　} } getA.fn(); //此时this指向对向getA var getA={ 　　a:1, 　　fn:function(){ 　　　　console.log(this.a) //1 　　} } window.getA.fn(); //此时this仍然指向getA()，this只会指向他的上一级 var getA={ 　　a:1, 　　b:{ 　　　　a:5, 　　　　fn:function(){ 　　　　　　console.log(this.a); //5 　　　　} 　　} } getA.b.fn(); var getA={ 　　a:1, 　　b:{ 　　　　a:5, 　　　　fn:function(){ 　　　　　　console.log(this.a); //undefined 　　　　} 　　} } var c = getA.b.fn; c(); /

原因 最近在写 unar.js（一个技术超越react angular vue）的mvvm库。通过研究proxy的可行性。故作以下研究 Proxy代理一个函数 var fn=function(){ console.log("fn") } var proxyFn=new Proxy(fn,{ apply:function(target,scope,args){ target() } }) proxyFn()//fn proxyFn.call(window)//fn proxyFn.apply(window)//fn //通过proxy的平常调用，call，apply调用都走代理的apply方法 //这个方法参数可以穿目标代理函数，目标代理函数的作用域，和参数 Proxy引入Reflect本质 var fn=function(...args){ console.log(this,args) } var proxyFn=new Proxy(fn,{ apply:function(target,scope,args){ target.call(scope,...args) } }) proxyFn(1)//Window,[1] proxyFn.call(window,1)//Window,[1] proxyFn.apply(window,[1])//Window,[1] Reflect实用

我们工作中免不了运用promise用来解决异步回调问题。平时用的很多库或者插件都运用了promise 例如axios、fetch等等。但是你知道promise是咋写出来的呢？ 别怕～这里有本promisesA+规范，便宜点10元卖给你了。 ERvaA3z.png 1、Promise 的声明 首先呢，promise肯定是一个类，我们就用class来声明。 • 由于 new Promise((resolve, reject)=>{}) ，所以传入一个参数（函数），秘籍里叫他executor，传入就执行。 •executor里面有两个参数，一个叫resolve（成功），一个叫reject（失败）。 •由于resolve和reject可执行，所以都是函数，我们用let声明。 class Promise{ // 构造器 constructor(executor){ // 成功 let resolve = () => { }; // 失败 let reject = () => { }; // 立即执行 executor(resolve, reject); } } 解决基本状态 秘籍对Promise有规定： •Promise存在三个状态（state）pending、fulfilled、rejected •pending（等待态）为初始态，并可以转化为fulfilled（成功态）和rejected

1.Function.apply.bind(…) 我在学习promise部分的时候遇到了这样的代码： Promise.resolve([10,20]).then(Function.apply.bind(function(x, y){ console.log(x, y); }, null)); // 10,20 看到这里我已经蒙圈了，Function.apply.bind(…)是个什么操作？可能很多人和我一样之前只接触过Function.bind.apply(…)。 于是查了一下文档，大致明白了其中的含义。先撇开Promise不谈，直接来看Function.apply.bind(…)： var sum = function(x, y) { console.log(x, y); } var foo = Function.apply.bind(sum, null); foo([10, 20]); // 10, 20 这里我们有一个函数sum，通过Function.apply.bind(sum, null)我们创建了一个新的函数foo(…)。 我们一步步分析Function.apply.bind(sum, null)这段代码。 sum.apply(null, [10, 20])这句代码将第一个参数置为null，第二个参数是一个数组，用于拆开后作为sum的最终参数。 熟悉sum.apply(

js： function bubbleSort(a, fn) { for (var i = a.length - 1; i >= 1; i--) for (var j = 0; j < i; j++) if (fn(a[j], a[j + 1])) swapArray(a, j, j + 1); return a; } function selectionSort(a, fn) { for (var i = a.length - 1; i >= 1; i--) { var pos = i; for (var j = 0; j < i; j++) if (fn(a[j], a[pos])) pos = j; if (i != pos) swapArray(a, i, pos); } return a; } function swapArray(a, i1, i2) { [a[i1], a[i2]] = [a[i2], a[i1]]; } function isFn(obj) { return typeof obj === 'function'; } function mysort(arr, fn) { return selectionSort(arr, isFn(fn) ? fn : (a, b) => a > b); } module.exports = mysort; 引入：

（1）面向对象三大特征:继承,多态(抽象),封装 （2）如何把一个对象的成员赋值给另一个对象 for(var key in arr)用遍历一个对象的所有属性,再去赋值给另一个对象,arr[key]或者arr.key 形成封装函数但对象与对象间的继承不是真正的继承,是属于对象的拷贝 function extend(parent,child){ for(var key in parent){ if(child[key]){ continue;} child[key]=parent[key];}} （3）真正的继承指的是类型与类型间的关系,在js中描述一个类型通过构造函数来实现 继承的作用是通过代码重用,通过新建一个父类型,将子类型中共同成员提升到父类型中 用在子类型上新建原型来实现 1原型继承,但并不实用,因为new构造函数只调用函数一次且不能设置构造函数的参数 Child.portotype = new Parent(); 但是注意直接注意该会改变Child的constructor属性 要加Child.prototype.constructor = Child;//这个在设置原型的时候都要加 2bind()--改变函数的this指针方向并返回一个新的函数,并不调用函数,所以要新建一个变量来接受返回的值 function fn(x,y){} var o = {} var a = fn

函数 函数命名方法 （1）function命令： function print(){ console.log(s); } （2）函数表达式： var print=function(){ console.log(s); } （3）function构造函数： var add=new Function(‘x’, ‘y’,‘return x+y’); 等同于 function add(x,y){ return x+y; } 函数名提升（预解析） fn(); //1 函数预解析，会把函数体内容解析出来 function fn(){ console.log(1); } console.log(a); //undefined 变量预解析不会解析出变量值 var a=2; console.log(typeof fn); //Object 变量预解析高于函数预解析，函数预解析在后，会覆盖前边解析的变量类型 function fn(){} var fn=1; console.log(foo()); //错误 通过函数表达式命名的函数，在预解析时解析出的是变量形式 var foo=function(){ console.log(1); } var foo=function(){ //函数表达式可以加()直接执行，function声明不可以 console.log(0); }(); 函数调用