写在前面

vue中关于插槽的文档说明很短，语言又写的很凝练，再加上其和methods，data，computed等常用选项使用频率、使用先后上的差别，这就有可能造成初次接触插槽的开发者容易产生“算了吧，回头再学，反正已经可以写基础组件了”，于是就关闭了vue说明文档。

实际上，插槽的概念很简单，下面通过分三部分来讲。这个部分也是按照vue说明文档的顺序来写的。

进入三部分之前，先让还没接触过插槽的同学对什么是插槽有一个简单的概念：插槽，也就是slot，是组件的一块HTML模板，这块模板显示不显示、以及怎样显示由父组件来决定。 实际上，一个slot最核心的两个问题这里就点出来了，是显示不显示和怎样显示。

由于插槽是一块模板，所以，对于任何一个组件，从模板种类的角度来分，其实都可以分为非插槽模板和插槽模板两大类。
非插槽模板指的是html模板，指的是‘div、span、ul、table’这些，非插槽模板的显示与隐藏以及怎样显示由插件自身控制；插槽模板是slot，它是一个空壳子，因为它显示与隐藏以及最后用什么样的html模板显示由父组件控制。但是插槽显示的位置确由子组件自身决定，slot写在组件template的哪块，父组件传过来的模板将来就显示在哪块。

单个插槽 | 默认插槽 | 匿名插槽

首先是单个插槽，单个插槽是vue的官方叫法，但是其实也可以叫它默认插槽，或者与具名插槽相对，我们可以叫它匿名插槽。因为它不用设置name属性。

单个插槽可以放置在组件的任意位置，但是就像它的名字一样，一个组件中只能有一个该类插槽。相对应的，具名插槽就可以有很多个，只要名字（name属性）不同就可以了。

下面通过一个例子来展示。

父组件：

<template>
    <div class="father">
        <h3>这里是父组件</h3>
        <child>
            <div class="tmpl">
              <span>菜单1</span>
              <span>菜单2</span>
              <span>菜单3</span>
              <span>菜单4</span>
              <span>菜单5</span>
              <span>菜单6</span>
            </div>
        </child>
    </div>
</template>

子组件：

<template>
    <div class="child">
        <h3>这里是子组件</h3>
        <slot></slot>
    </div>
</template>

在这个例子里，因为父组件在<child></child>里面写了html模板，那么子组件的匿名插槽这块模板就是下面这样。也就是说，子组件的匿名插槽被使用了，是被下面这块模板使用了。

<div class="tmpl">
  <span>菜单1</span>
  <span>菜单2</span>
  <span>菜单3</span>
  <span>菜单4</span>
  <span>菜单5</span>
  <span>菜单6</span>
</div>

最终的渲染结果如图所示：

注：所有demo都加了样式，以方便观察。其中，父组件以灰色背景填充，子组件都以浅蓝色填充。

具名插槽

匿名插槽没有name属性，所以是匿名插槽，那么，插槽加了name属性，就变成了具名插槽。具名插槽可以在一个组件中出现N次。出现在不同的位置。下面的例子，就是一个有两个具名插槽和单个插槽的组件，这三个插槽被父组件用同一套css样式显示了出来，不同的是内容上略有区别。

父组件：

<template>
  <div class="father">
    <h3>这里是父组件</h3>
    <child>
      <div class="tmpl" slot="up">
        <span>菜单1</span>
        <span>菜单2</span>
        <span>菜单3</span>
        <span>菜单4</span>
        <span>菜单5</span>
        <span>菜单6</span>
      </div>
      <div class="tmpl" slot="down">
        <span>菜单-1</span>
        <span>菜单-2</span>
        <span>菜单-3</span>
        <span>菜单-4</span>
        <span>菜单-5</span>
        <span>菜单-6</span>
      </div>
      <div class="tmpl">
        <span>菜单->1</span>
        <span>菜单->2</span>
        <span>菜单->3</span>
        <span>菜单->4</span>
        <span>菜单->5</span>
        <span>菜单->6</span>
      </div>
    </child>
  </div>
</template>

子组件：

<template>
  <div class="child">
    // 具名插槽
    <slot name="up"></slot>
    <h3>这里是子组件</h3>
    // 具名插槽
    <slot name="down"></slot>
    // 匿名插槽
    <slot></slot>
  </div>
</template>

显示结果如图：

可以看到，父组件通过html模板上的slot属性关联具名插槽。没有slot属性的html模板默认关联匿名插槽。

作用域插槽 | 带数据的插槽

最后，就是我们的作用域插槽。这个稍微难理解一点。官方叫它作用域插槽，实际上，对比前面两种插槽，我们可以叫它带数据的插槽。什么意思呢，就是前面两种，都是在组件的template里面写

匿名插槽
<slot></slot>
具名插槽
<slot name="up"></slot>

但是作用域插槽要求，在slot上面绑定数据。也就是你得写成大概下面这个样子。

<slot name="up" :data="data"></slot>
 export default {
    data: function(){
      return {
        data: ['zhangsan','lisi','wanwu','zhaoliu','tianqi','xiaoba']
      }
    },
}

我们前面说了，插槽最后显示不显示是看父组件有没有在child下面写模板，像下面那样。

<child>
   html模板
</child>

写了，插槽就总得在浏览器上显示点东西，东西就是html该有的模样，没写，插槽就是空壳子，啥都没有。
OK，我们说有html模板的情况，就是父组件会往子组件插模板的情况，那到底插一套什么样的样式呢，这由父组件的html+css共同决定，但是这套样式里面的内容呢？

正因为作用域插槽绑定了一套数据，父组件可以拿来用。于是，情况就变成了这样：样式父组件说了算，但内容可以显示子组件插槽绑定的。

我们再来对比，作用域插槽和单个插槽和具名插槽的区别，因为单个插槽和具名插槽不绑定数据，所以父组件是提供的模板要既包括样式由包括内容的，上面的例子中，你看到的文字，“菜单1”，“菜单2”都是父组件自己提供的内容；而作用域插槽，父组件只需要提供一套样式（在确实用作用域插槽绑定的数据的前提下）。

下面的例子，你就能看到，父组件提供了三种样式(分别是flex、ul、直接显示)，都没有提供数据，数据使用的都是子组件插槽自己绑定的那个人名数组。

父组件：

<template>
  <div class="father">
    <h3>这里是父组件</h3>
    <!--第一次使用：用flex展示数据-->
    <child>
      <template slot-scope="user">
        <div class="tmpl">
          <span v-for="item in user.data">{{item}}</span>
        </div>
      </template>
 
    </child>
 
    <!--第二次使用：用列表展示数据-->
    <child>
      <template slot-scope="user">
        <ul>
          <li v-for="item in user.data">{{item}}</li>
        </ul>
      </template>
 
    </child>
 
    <!--第三次使用：直接显示数据-->
    <child>
      <template slot-scope="user">
       {{user.data}}
      </template>
 
    </child>
 
    <!--第四次使用：不使用其提供的数据, 作用域插槽退变成匿名插槽-->
    <child>
      我就是模板
    </child>
  </div>
</template>

子组件：

<template>
  <div class="child">
 
    <h3>这里是子组件</h3>
    // 作用域插槽
    <slot  :data="data"></slot>
  </div>
</template>
 
 export default {
    data: function(){
      return {
        data: ['zhangsan','lisi','wanwu','zhaoliu','tianqi','xiaoba']
      }
    }
}

结果如图所示：

github

以上三个demo就放在GitHub了，有需要的可以去取。使用非常方便，是基于vue-cli搭建工程。

https://github.com/cunzaizhuyi/vue-slot-demo

转载地址：https://segmentfault.com/a/1190000012996217

崩溃提示：Terminating app due to uncaught exception 'NSGenericException', reason: '*** Collection <CALayerArray: 0x14df0bd0> was mutated while being enumerated.'



当程序出现这个提示的时候，是因为你一边便利数组，又同时修改这个数组里面的内容，导致崩溃，网上的方法如下：

NSMutableArray * arrayTemp = xxx;

NSArray * array = [NSArray arrayWithArray: arrayTemp];

for (NSDictionary * dic in array) {

if (condition){

[arrayTemp removeObject:dic];

}

}

这种方法就是在定义一个一模一样的数组，便利数组A然后操作数组B

今天终于找到了一个更快接的删除数组里面的内容以及修改数组里面的内容的方法：

NSMutableArray *tempArray = [[NSMutableArray alloc]initWithObjects:@"12",@"23",@"34",@"45",@"56", nil];

[tempArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {

if ([obj isEqualToString:@"34"]) {

*stop = YES;

if (*stop == YES) {

[tempArray replaceObjectAtIndex:idx withObject:@"3333333"];

}

}

if (*stop) {

NSLog(@"array is %@",tempArray);

}

}];



利用block来操作，根据查阅资料，发现block便利比for便利快20%左右，这个的原理是这样的：

找到符合的条件之后，暂停遍历，然后修改数组的内容

转自：https://www.cnblogs.com/rglmuselily/p/6249015.html

Android中只允许UI线程（也就是主线程）修改Activity里的UI组件。实际开发中，新启动的线程需要周期性地改变界面组件的属性值就需要借助Handler的消息传递机制。

Handler类

实例：自动轮播图片

package com.example.testapp1.activity;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import com.example.testapp1.R;
import com.example.testapp1.control.RoundImageView;

import java.lang.ref.WeakReference;
import java.util.Timer;
import java.util.TimerTask;

public class NextActivity extends AppCompatActivity {
    private RoundImageView imageShow;

    static class ImageHandler extends Handler {
        private WeakReference nextActivityWeakReference;

        public ImageHandler(WeakReference nextActivityWeakReference) {
            this.nextActivityWeakReference = nextActivityWeakReference;
        }

        private int[] imageIds = new int[]{R.drawable.a383f7735d8cd09fb81ff979b2f3d599
            , R.drawable.b6ab4abe4db592b27ea678345b0c3416
            , R.mipmap.head1
            , R.drawable.b6ab4abe4db592b27ea678345b0c3416};
        private int currentImageId = 0;

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            if (msg.what == 0x1233) {
                nextActivityWeakReference.get().imageShow.setImageResource(imageIds[currentImageId++ % imageIds.length]);
            }
        }
    }

    ImageHandler imageHandler = new ImageHandler(new WeakReference<>(this));

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.next);
        imageShow = findViewById(R.id.headImg);
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                imageHandler.sendEmptyMessage(0x1233);
            }
        }, 0, 2000);
    }
}

上述代码中，TimeTask对象的本质就是启动一条新线程。

Handler、Loop、MessageQueue的工作原理

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

该构造器使用了private修饰，表明程序员无法通过构造器创建Looper对象。从上面的代码不难看出，程序在初始化Looper时会创建一个与之关联的 MessagQueue，这个MessageOuee就负责管理消息。

Handler:它的作用有两个，即发送消息和处理消息，程序使用Handler发送消息，由Handler发送的消息必须被送到指定的MessageQueue。也就是说，如果希望Handler正常工作，必须在当前线程中有一个MessageQueue；否则消息就没有 MessageQueue进行保存了。不过MessageQueue是由Looper负责管理的，也就是说，如果希望Handler正常工作，必须在当前线程中有一个Looper对象。为了保证当前线程中有Looper对象，可以分如下两种情况处理。
在主UI线程中，系统已经初始化了一个Looper对象，因此程序直接创建Handler即可，然后就可通过Handler来发送消息、处理消息了。
程序员自己启动的子线程，必须自己创建一个Looper对象，并启动它。创建 Looper对象调用它的prepare(方法即可。
prepare()方法保证每个线程最多只有一个Looper对象。prepare()方法的源代码如下：

public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

接下来调用Looper的静态loop()方法来启动它。loop()方法使用一个死循环不断取出MessageQueue中的消息，并将取出的消息分给该消息对应的Handler进行处理。下面是Looper类的loop()方法的源代码：

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");

        }        if (me.mInLoop) {
            Slog.w(TAG, "Loop again would have the queued messages be executed"
                    + " before this one completed.");
        }

        me.mInLoop = true;
        final MessageQueue queue = me.mQueue;

// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

// Allow overriding a threshold with a system prop. e.g.
// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
        final int thresholdOverride =
                SystemProperties.getInt("log.looper."
                        + Process.myUid() + "."
                        + Thread.currentThread().getName()
                        + ".slow", 0);

        boolean slowDeliveryDetected = false;

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
// No message indicates that the message queue is quitting.
                return;
            }

// This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
// Make sure the observer won't change while processing a transaction.
            final Observer observer = sObserver;

            final long traceTag = me.mTraceTag;
            long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
            long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
            if (thresholdOverride > 0) {
                slowDispatchThresholdMs = thresholdOverride;
                slowDeliveryThresholdMs = thresholdOverride;
            }
            final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
            final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);

            final boolean needStartTime = logSlowDelivery || logSlowDispatch;
            final boolean needEndTime = logSlowDispatch;

            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }

            final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
            final long dispatchEnd;
            Object token = null;
            if (observer != null) {
                token = observer.messageDispatchStarting();
            }
            long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
            try {
                msg.target.dispatchMessage(msg);
                if (observer != null) {
                    observer.messageDispatched(token, msg);
                }
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } catch (Exception exception) {
                if (observer != null) {
                    observer.dispatchingThrewException(token, msg, exception);
                }
                throw exception;
            } finally {
                ThreadLocalWorkSource.restore(origWorkSource);
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            if (logSlowDelivery) {
                if (slowDeliveryDetected) {
                    if ((dispatchStart - msg.when) <= 10) {
                        Slog.w(TAG, "Drained");
                        slowDeliveryDetected = false;
                    }
                } else {
                    if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                            msg)) {
// Once we write a slow delivery log, suppress until the queue drains.
                        slowDeliveryDetected = true;
                    }
                }
            }
            if (logSlowDispatch) {
                showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
            }

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

归纳起来，Looper、MessageQueue、Handler各自的作用如下：

在线程中使用Handler的步骤如下:

实例：使用新线程实现点击图片弹出图片内容

        android:id="@+id/constraintlayout2"
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_gravity="center"
        android:layout_height="wrap_content">

android:id="@+id/imageView"
        android:layout_width="50dp"
        android:layout_height="50dp"
        tools:ignore="MissingConstraints"
        tools:src="@drawable/ic_launcher_foreground" />

android:id="@+id/textView3"
        android:layout_width="100dp"
        android:layout_height="50dp"
        android:gravity="center"
        android:visibility="gone"
        app:layout_constraintStart_toEndOf="@+id/imageView"
        app:layout_constraintTop_toTopOf="@+id/constraintlayout2"
        tools:text="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
        tools:visibility="visible" />

布局文件比较简单，就是使用约束布局，在其中放入一个图片控件和文本控件（不展示）。
JAVA代码：

private ImageThread imageThread;

class ImageHandler extends Handler {
    @Override
    public void handleMessage(@NonNull Message msg) {
        super.handleMessage(msg);
        if(msg.what == 0x123){
            String imageText = msg.getData().getString("ImageText");
            Toast.makeText(mContext, imageText, Toast.LENGTH_LONG).show();
        }
    }
}

class ImageThread extends Thread {
    private Handler mHandler;

    @Override
    public void run() {
        Looper.prepare();
        mHandler = new ImageHandler();
        Looper.loop();
    }
}

上述代码定义了一个线程的子类和Handler的子类，在Android Studio的比较新的版本不能直接使用Handler类实例对象并重新handleMessage（已废弃，旧版本可以），必须通过Handler子类实例对象
在Activity的onCreate()或者Fragment的onCreateView()方法中加入以下代码：启动新线程，监听图片的点击事件，向新线程中的Handler发送消息。

imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
        Message msg = new Message();
        msg.what = 0x123;
        Bundle bundle = new Bundle();
        bundle.putString("ImageText", imageData.getImageText());
        msg.setData(bundle);
        imageThread.mHandler.sendMessage(msg);
        }
        });
        imageThread = new ImageThread();
        imageThread.start();

————————————————
版权声明：本文为CSDN博主「maisomgan」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45828419/article/details/115523133

glide

glide库的优点：

//用于网络请求

//它可以监听用户的连接状态并在用户重新连接到网络时重启之前失败的请求

//用于硬盘缓存和读取

glide的使用

.into(new SimpleTarget(){
        @Override
        public void onResourceReady(Bitmap resource, Transition transition) {
            Drawable drawable = new BitmapDrawable(resource);
            mConstraintLayout.setBackground(drawable);
        }
    });

加载本地图片：

File file = new File(getExternalCacheDir() + "/image.jpg");
Glide.with(this).load(file).into(imageView);

加载应用资源：

int resource = R.drawable.image;
Glide.with(this).load(resource).into(imageView);

加载二进制流：

byte[] image = getImageBytes();
Glide.with(this).load(image).into(imageView);

加载Uri对象：

Uri imageUri = getImageUri();
Glide.with(this).load(imageUri).into(imageView);

注意with()方法中传入的实例会决定Glide加载图片的生命周期，如果传入的是Activity或者Fragment的实例，那么当这个Activity或Fragment被销毁的时候，图片加载也会停止。如果传入的是ApplicationContext，那么只有当应用程序被杀掉的时候，图片加载才会停止。
取消图片：Glide.with(this).load(url).clear();
————————————————
版权声明：本文为CSDN博主「maisomgan」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45828419/article/details/115632155

okhttp

call.enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            Toast.makeText(OkHttpActivity.this, "get failed", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onResponse(Call call, final Response response) throws IOException {
            final String res = response.body().string();
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    textView.setText(res);
                }
            });
        }
    });

OkHttp进行Post请求
使用OkHttp进行Post请求和进行Get请求很类似,只需要以下五步：

获取OkHttpClient对象
OkHttpClient okHttpClient = new OkHttpClient();
1
构建FormBody或RequestBody或构架我们自己的RequestBody,传入参数

//OkHttp进行Post请求提交键值对
    FormBody formBody = new FormBody.Builder()
    .add("username", "admin")
    .add("password", "admin")
    .build();

//OkHttp进行Post请求提交字符串
    RequestBody requestBody = RequestBody.create(MediaType.parse("text/plain;charset=utf-8"), "{username:admin;password:admin}");

//OkHttp进行Post请求上传文件
    File file = new File(Environment.getExternalStorageDirectory(), "1.png");
    if (!file.exists()){
        Toast.makeText(this, "文件不存在", Toast.LENGTH_SHORT).show();
    }else{
        RequestBody requestBody2 = RequestBody.create(MediaType.parse("application/octet-stream"), file);
    }

//OkHttp进行Post请求提交表单
    File file = new File(Environment.getExternalStorageDirectory(), "1.png");
    if (!file.exists()){
        Toast.makeText(this, "文件不存在", Toast.LENGTH_SHORT).show();
        return;
    }
    RequestBody muiltipartBody = new MultipartBody.Builder()
//一定要设置这句
    .setType(MultipartBody.FORM)
    .addFormDataPart("username", "admin")//
    .addFormDataPart("password", "admin")//
    .addFormDataPart("myfile", "1.png", RequestBody.create(MediaType.parse("application/octet-stream"), file))
    .build();
    构建Request,将FormBody作为Post方法的参数传入
    final Request request = new Request.Builder()
    .url("http://www.jianshu.com/")
    .post(formBody)
    .build();

    将Request封装为Call
    Call call = okHttpClient.newCall(request);
    1
    调用请求,重写回调方法
    call.enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            Toast.makeText(OkHttpActivity.this, "Post Failed", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            final String res = response.body().string();
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    textView.setText(res);
                }
            });
        }
    });

————————————————
版权声明：本文为CSDN博主「maisomgan」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45828419/article/details/115632155

JavaScript 逐点突破系列 – 变幻莫测的this指向

this指向

事件调用环境

谁触发事件，函数里面的this指向就是谁

let button = document.getElemetById('button')
button.onclick = function () {
	console.log(this)		//button对象
}

全局环境
浏览器环境下

console.log(this) // window

node环境下

console.log(this) // module.exports

函数内部

this最终指向的是调用的对象，和声明没有直接关系

var object = {
     name: 'object',
     getName: function() {
             console.log(this)
    }
}
var bar = object.getName // 只是函数声明并未调用
object.getName()    // object对象
window.object.getName()    // object对象
/* 函数被多层对象所包含，如果函数被最外层对象调用，this指向
的也只是它上一级的对象。*/
bar()  // window对象

构造函数

构造函数中的this指向的是实例对象

let fn = function(){
	this.id = 'xiaoMing'	
	console.log(this.id)
}
let fn1 = new fn()		//this指向fn1对象

new 的内部原理

【1】创建一个空对象 obj；
【2】把 child 的__proto__ 指向构造函数 parent 的原型对象 prototype，此时便建立了 obj 对象的原型链：child ->parent.prototype->Object.prototype->null
【3】在 child 对象的执行环境调用 parent 函数并传递参数。
【4】考察第 3 步的返回值，如果无返回值 或者 返回一个非对象值，则将 child 作为新对象返回；否则会将 result 作为新对象返回。this绑定的是返回的对象。

function fn(){
	this.num = 10;
}
fn.num = 20;
fn.prototype.num = 30;
fn.prototype.method = function() {
	console.log(this.num);
}
var prototype = fn.prototype
var method = prototype.method
new fn().method() // 10
prototype.method() // 30
method() // undefined

箭头函数

箭头函数本身没有this和arguments，箭头函数继承上下文的this关键字，也就是说指向上一层作用域的this。
注意点

1. 函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象

function foo() {
  return () => {
    return () => {
      return () => {
        console.log('id:', this.id);
      };
    };
  };
}

var f = foo.call({id: 1});
var t1 = f.call({id: 2})()(); // id: 1
var t2 = f().call({id: 3})(); // id: 1
var t3 = f()().call({id: 4}); // id: 1

上面代码之中，只有一个this，就是函数foo的this，所以t1、t2、t3都输出同样的结果。因为所有的内层函数都是箭头函数，都没有自己的this，它们的this其实都是最外层foo函数的this。

除了this，以下三个变量在箭头函数之中也是不存在的，指向外层函数的对应变量：arguments、super、new.target。

由于箭头函数没有自己的this，所以当然也就不能用call()、apply()、bind()这些方法去改变this的指向。

不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

修改this指向

func.call(this, arg1, arg2);
func.apply(this, [arg1, arg2])
func.bind(this, arg1, arg2)()

apply、call的区别

call 需要把参数按顺序传递进去，而 apply 则是把参数放在数组里。

bind和其他两种方法的区别

bind 是返回对应函数，便于稍后调用；apply 、call 则是立即调用 。

原文链接：https://blog.csdn.net/weixin_45495667/article/details/108801000

示例图:

简介

一个实用的多条件筛选菜单，在很多App上都能看到这个效果，如美团，爱奇艺电影票等

我的博客 自己造轮子--android常用多条件帅选菜单实现思路（类似美团，爱奇艺电影票下拉菜单）

特色

• 支持多级菜单
• 你可以完全自定义你的菜单样式，我这里只是封装了一些实用的方法，Tab的切换效果，菜单显示隐藏效果等
• 并非用popupWindow实现，无卡顿

Gradle Dependency

allprojects {

    repositories {

        ...

        maven { url "https://jitpack.io" }

    }

}



dependencies {

    compile 'com.github.dongjunkun:DropDownMenu:1.0.4'

}

使用

添加DropDownMenu 到你的布局文件，如下

<com.yyydjk.library.DropDownMenu

    android:id="@+id/dropDownMenu"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    app:ddmenuTextSize="13sp" //tab字体大小

    app:ddtextUnselectedColor="@color/drop_down_unselected" //tab未选中颜色

    app:ddtextSelectedColor="@color/drop_down_selected" //tab选中颜色

    app:dddividerColor="@color/gray"    //分割线颜色

    app:ddunderlineColor="@color/gray"  //下划线颜色

    app:ddmenuSelectedIcon="@mipmap/drop_down_selected_icon" //tab选中状态图标

    app:ddmenuUnselectedIcon="@mipmap/drop_down_unselected_icon"//tab未选中状态图标

    app:ddmaskColor="@color/mask_color"     //遮罩颜色，一般是半透明

    app:ddmenuBackgroundColor="@color/white" //tab 背景颜色

    app:ddmenuMenuHeightPercent="0.5" 菜单的最大高度，根据屏幕高度的百分比设置

    ...

 />

我们只需要在java代码中调用下面的代码

 //tabs 所有标题，popupViews  所有菜单，contentView 内容

mDropDownMenu.setDropDownMenu(tabs, popupViews, contentView);

代码下载:DropDownMenu-master.zip

原文链接:https://github.com/dongjunkun/DropDownMenu

• 一.isa指针

• 上篇文章我们提到了实例对象，类对象和元类对象的存储结构里面都包含了一个isa指针，今天我们来看看它的作用，以及实例对象类对象元类对象之间的关联

• 
  

• 实例对象的isa指针

  
  
  • 当实例对象（instance）调用对象方法的时候，实例对象的isa指针指向类对象（class），在类对象中，查找对象方法并调用
  
  


• 
  

  类对象的isa指针

  
  

  • 类对象（class）的isa指针指向元类对象（meta-class），当调用类方法时，类对象的isa指针指向元类对象，并在元类里面找到类方法并调用

    二.类对象的supercl

    • 先两个类，一个Person继承自NSObject，一个类继承自Person
    /// Person继承自NSObject
    

    @interface Person : NSObject
    
    -(void)perMethod;
    
    +(void)perEat;
    
    @end
    
    @implementation Person
    
    -(void)perMethod{
    
    }
    
    +(void)perEat{ 
    
    }
    
    
    
    @end
    
    
    
    /// student继承自Person
    
    @interface Student : Person
    
    -(void)StudentMethod;
    
    +(void)StudentEat;
    
    @end
    
    @implementation Student
    
    
    
    -(void)StudentMethod{  
    
    }
    
    +(void)StudentEat{
    
    }
    
    
    
    

    
    

    
    
    • 当实例对象调用自身的对象方法时，它在自身的class对象中找到StudentMethod方法

    •         Student *student = [[Student alloc]init];
      
              [student StudentMethod]
      
      

      
      

      
      
      • 当实例对象调用父类的方法的时候
      
      

      
      

              Student *student = [[Student alloc]init];
      
              [student perMethod];当子类调用父类的实例方法的时候，子类的class类对象的superclass指针指向父类，直至基类（NSObject）找到方法并执行（注意，这里指的是实例方法，也就是减号方法）
      三.元类对象的superclass 指针
      当子类调用父类的类方法的时候，子类的superclass指向父类，并查找到相应的类方法，调用
      

    • [Student perEat];

    • 
      

    • 总的来说，isa，superclass的的关系可以用一副经典的图来表示

      
      

    • instance的isa指向class

      class的isa指向meta-class

      meta-class的isa指向基类的meta-class

      class的superclass指向父类的class

    • 
      
    • 
      
    • 作者：枫紫_6174
      原贴链接：https://www.jianshu.com/p/26f37fb21151
      

一、什么是函数防抖跟节流？

函数防抖： 在事件被触发n秒之后在执行回调函数，如果在n秒内又被触发 ，则重新计时。
函数节流： 规定一个单位时间，规定在这个时间内，只能执行一次回调函数，如果在这个时间内呗触发多次，则只有一次失效。表现形式就是它有自己的一个执行频率。

二、JavaScript实现

1.函数防抖

代码如下（示例）：

function debounce(callback, wait) {
	let timer = null;
	return function(){
		let _this = this,
		arg = arguments;
		if(!!timer){
			clearTimeout(timer)
			timer = null
		}
		timer = setTimeout(function(){
			callback.call(_this,arg)
		},wait)
	}
}
let _debounce = debounce(function() {
	console.log('dshdihdi')
}, 1000)

2.函数节流

代码如下（示例）：

// 函数节流，时间戳版本
function throttle(callback, wait) {
	let time = new Date().getTime();
	return function() {
		let _this = this,
		arg = arguments;
		let nowTime = new Date().getTime();
		if (nowTime - time >= wait){
			callback.call(_this,...arg)
			time = nowTime
		}
	}
}
let _throttle = throttle(function(e) {
	console.log(e)
	console.log(arguments)
}, 1000)

函数节流： 懒加载分页请求资源、音乐播放进度条更新等等

函数防抖： 频繁操作点赞、登录注册、需要提交最新信息等等

原文链接：https://blog.csdn.net/qq_45924621/article/details/115586112

• 上一篇文章我们讲到了load方法，今天我们来看看initialize

新建项目，新建类（和上一篇文章所建的类相同，方便大家理解，具体的类相关关系可以看上一篇文章我的介绍）类结构图如下

将原来的load方法换成initialize

说明：NSLog(@"---")是由于我建的是命令行工程，不写这个，貌似不能显示控制台，Xcode版本是12，当然你们的要显示控制台，直接去掉这行代码

从输出结果可以看到没有任何关于initialize的打印，程序直接退出

• 2.initialize的打印

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

    }

    return 0;

}

运行结果：

2020-12-04 14:59:17.417072+0800 TCCateogry[1616:79391] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

从上面的输出结果我们可以看到，TCPerson (TCtest2) +initialize打印

load是直接函数指针直接调用，类，分类，继承等等

[TCPerson alloc]就是相当于该类发送消息，但是它只会调用类，分类的其中一个（取决于编译顺序，从输出结果可以看出，initialize走的是objc_msgSend，而load直接通过函数指针直接调用，所以initialize通过isa方法查找调用.

多次向TCPerson发送消息的输出结果

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

    }

    return 0;

}

输出结果：

2020-12-04 15:11:12.246442+0800 TCCateogry[1659:85317] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

initialize只会调用一次

我们再来看看继承关系中，initialize的调用

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCStudent alloc];

      

    }

    return 0;

}

输出结果：

2020-12-04 15:14:58.705423+0800 TCCateogry[1705:87507] TCPerson (TCtest2) +initialize

2020-12-04 15:14:58.705750+0800 TCCateogry[1705:87507] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

从输出结果来看，子类调用initialize之前，会先调用父类的initialize，再调用自己的initialize，当然无论父类调用initialize，还是子类调用initialize，如果有多个分类（这里指的是父类调用父类的分类，子类调用子类的分类），调用initialize取决于分类的编译顺序（调用后编译分类中的initialize，类似于压栈，先进后出），值得注意的是，无论父类子类的initialize，都只调用一次

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];

        [TCPerson alloc];

        [TCStudent alloc];

        [TCStudent alloc];

    }

    return 0;

}

输出结果：

020-12-04 15:23:27.168243+0800 TCCateogry[1731:91248] TCPerson (TCtest2) +initialize

2020-12-04 15:23:27.168601+0800 TCCateogry[1731:91248] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

如果子类（子类的分类也不实现）不实现initialize，则父类的initialize就调用多次

#import "TCStudent.h"



@implementation TCStudent

//+ (void)initialize{

//    NSLog(@"TCStudent +initialize");

//}

@end

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];   

        [TCStudent alloc];

    }

    return 0;

}

2020-12-04 15:37:09.055459+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

2020-12-04 15:37:09.055775+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

+ (void)initialize{

    NSLog(@"TCStudent +initialize");

}

@end

#import "TCStudent+TCStudentTest1.h"



@implementation TCStudent (TCStudentTest1)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest1) +initialize");

}

@end#import "TCStudent+TCStudentTest2.h"



@implementation TCStudent (TCStudentTest2)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest2) +initialize");

}

@end

2020-12-04 15:41:21.863260+0800 TCCateogry[1868:100750] TCPerson (TCtest2) +initialize

2020-12-04 15:41:21.863568+0800 TCCateogry[1868:100750] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

new 操作符做的事情 - 01

1. 创建了一个全新的对象。
2. 将对象链接到这个函数的 prototype 对象上。
3. 执行构造函数，并将 this 绑定到新创建的对象上。
4. 判断构造函数执行返回的结果是否是引用数据类型，若是则返回构造函数执行的结果，否则返回创建的对象。

new 操作符做的事情 - 02

1. 创建一个全新的对象 (无原型的Object.create(null)) 。
2. 目的是保存 new 出来的实例的所有属性。
3. 将构造函数的原型赋值给新创建的对象的原型。
4. 目的是将构造函数原型上的属性继承下来。
5. 调用构造函数，并将 this 指向新建的对象。
6. 目的是让构造函数内的属性全部转交到该对象上，使得 this 指向改变，方法有三 : apply、call、bind 。
7. 判断构造函数调用的方式，如果是 new 的调用方式，则返回经过加工后的新对象，如果是普通调用方式，则直接返回构造函数调用时的返回值。

function myNew(Constructor, ...args) {
	// 判断 Constructor 参数是否是函数
	if (typeof Constructor !== 'function') {
		return 'Constructor.apply is not a function';
	};

	// 1、创建了一个全新的对象。
	let newObject = {};

	// 2、将对象链接到这个函数的 prototype 对象上。
	newObject.__proto__ = Constructor.prototype;

	// 此处是把 1 / 2 步结合到一起
	// const newObject = Object.create(Constructor.prototype);

	// 3、执行构造函数，
	// 并将 this 绑定到新创建的对象上。
	let result = Constructor.apply(newObject, args);

	// 4. 判断构造函数执行返回的结果是否是引用数据类型，
	// 若是则返回构造函数执行的结果，
	// 否则返回创建的对象。
	if ((result !== null && typeof result === 'object') || (typeof result === 'function')) {
		return result;
	} else {
		return newObject;
	};
};

// 需要被 new 的函数
function NewTest(args) {
	this.dataValue = args;
	return this;
};

// 定义参数
let dataObj = {
	sname: '杨万里',
	number: 3,
	web: 'vue'
};
let dataArray = [5, 'uniApp', '范仲淹'];

// 执行 myNew 函数
let test = myNew(NewTest, 1, 'JavaScript', '辛弃疾', dataObj, dataArray);
console.log(test); // NewTest {dataValue: Array(5)}

本文链接：https://blog.csdn.net/weixin_51157081/article/details/115577751

一、OpenGL中的坐标系

1. 2D笛卡尔坐标系（X轴，Y轴），平面图形，视口（显示窗口区域系数）

2. 3D笛卡尔坐标系（X轴，Y轴，Z轴），立体图形

3. OpenGL的投影方式有：
透视投影：用来渲染立体图形，有远小近大的效果。具有更加逼真的效果
正投影：只能用来设置平面图形

4.坐标系的分类：

① 惯性坐标系：没有什么参考价值，只要用来平移到世界坐标系

② 世界坐标系：大环境中的位置，系统的绝对坐标

③ 物体空间坐标系（局部空间）：局部空间中的位置

④ 摄像机坐标系：观察空间（观察者）

5.坐标系之间的变换

① 物体坐标系，模型变换

② 转换到世界坐标系，视变换

③ 转换到观察者坐标系/摄像机坐标系，投影变换

④ 转换到裁剪坐标系，透视除法

⑤ 转换到规范化设备坐标，视口变换

⑥ 转换到屏幕坐标

注：① - ④ 是可以由开发者自定义完成的，⑤ - ⑥是有系统OpenGL来完成的

二、着色器的渲染流程

1.顶点数据

2.顶点着色器：接收顶点数据，单独处理每个顶点

3.细分着色器：
  ① 可选：描述物体形状，在管线中生成新的饿几何平面模型，生成最终形态
  ② 组分控制着色器/细分计算着色器：对所有的图形进行修改几何图元类型或者放弃所有图像

4.几何着色器

5.图元设置

6.剪切：剪切窗口之外的绘制

7.光栅化：输入图元的数学描述，转化为与屏幕对应位置像素片元，简称光栅化

8.片元着色器：片元着色器以及深度值，然后传递到片元测试和混合模块

9.效果

三、补充几个知识点

1.图片的渲染流程：
  ① GPU解码图片
  ② GPU纹理混合、顶点计算、像素点填充计算、渲染到帧缓冲区
  ③ 时钟信号：垂直同步、水平同步
  ④ iOS设备双缓冲机制：显示系统通常会引入两个帧缓冲区，双缓冲机制

2.MVP矩阵：
  ① model：物体的一些变化
  ② view：观察
  ③ projection：3D矩阵

3.强制解压缩：对图片进行重新绘制，得到一张新的压缩后的位图，其中用到的最核心的函数是：GCBitmapContextCreate

需求, 使用canvas绘制图片和文字, 生成图片

<!--pages/canvas/canvas.wxml-->
<view>
  <view class="container">
    <button bind:tap="start" class="start" size="mini">选择图片</button>
    <button bind:tap="downloadCanvas" class="downloadCanvas" size="mini">下载</button>
    <button bind:tap="share" class="share" size="mini">分享</button>
    <!-- 分享图片功能 -->
  </view>
  <text>canvas区域</text>
  <canvas style='width:{{canvasWidth}}px;height:{{canvasHeight}}px;border: 1px solid grey;' canvas-id='myCanvas'></canvas>
  <image v-if="previewImage" :src="{{canvasImage}}"></image>
</view>

图片功能

先设置canvas区域的宽度和高度

js代码

data: {
    title: 'canvas绘制图片',
    canvasWidth: '', // canvas宽度
    canvasHeight: '', // canvas高度
    imagePath: '', // 分享的图片路径
    leftMargin: 0,
    topMargin: 0,
    imgInfo: {},
    ctx: [],
    canvasImage: '',
    previewImage: false,
    imgProportion: 0.8, // 图片占canvas画布宽度百分比
    imgToTop: 100 // 图片到canvas顶部的距离
  },
  onLoad: function(options) {
    var that = this
    var sysInfo = wx.getSystemInfo({
      success: function(res) {
        that.setData({
          canvasWidth: res.windowWidth,
          // 我这里选择canvas高度是系统高度的80%
          canvasHeight: res.windowHeight * 0.8
        })
        // 根据图片比例, 使图片居中
        let leftMargin = (res.windowWidth * (1 - that.data.imgProportion)) / 2
        that.setData({
          leftMargin
        })
      }
    })
  }

接下来下选择图片

// 点击选择图片按钮触发
start: function() {
    let that = this
    let ctx = wx.createCanvasContext('myCanvas')
    // 设置canvas背景色, 否则制作的图片是透明的
    ctx.setFillStyle('#f8f8f8')
    ctx.fillRect(0, 0, that.data.canvasWidth, that.data.canvasHeight)
    this.addImage(ctx)
  },
  // 添加图片
  addImage: function(ctx) {
    var that = this;
    let imgInfo = that.data.imgInfo
    var path
    wx.chooseImage({
      count: '1',
      success(res) {
        wx.getImageInfo({
          src: res.tempFilePaths[0],
          success: function(response) {
            // 返回的response里有图片的临时路径和图片信息(高度/宽度)
            that.setData({
              imgInfo: response,
              path: response.path
            })
            that.drawImage(ctx)
          }
        })
      }
    })
    this.addTitle(ctx)
  },

绘制文字和图

// 绘制图片
  drawImage(ctx) {
    let that = this
    let imgInfo = that.data.imgInfo
    let path = that.data.path
    // 计算图片宽度 宽度固定 高度等比缩放
    let imgWidth = that.data.canvasWidth * that.data.imgProportion
    let imgHeight = imgInfo.height / imgInfo.width * imgWidth
    // drawImage参数, 下面会说明
    ctx.drawImage(path, 0, 0, imgInfo.width, imgInfo.height, that.data.leftMargin, that.data.imgToTop, imgWidth, imgHeight)
    ctx.draw()
    that.data.previewImage = true
  },
  //绘制文字
  addTitle: function(ctx) {
    var str = this.data.title
    ctx.font = 'normal bold 16px sans-serif';
    ctx.setTextAlign('center'); // 文字居中
    ctx.setFillStyle("#222222");
    ctx.fillText(str, this.data.canvasWidth / 2, 45)  // 文字位置
  },

//点击下载按钮保存canvas图片
  downloadCanvas: function() {
    let that = this;
     // 判断用户是否选择了图片
    if (that.data.previewImage) {
      wx.canvasToTempFilePath({
        x: 0,
        y: 0,
        width: that.canvasWidth,
        height: that.canvasWidth,
        destWidth: that.canvasWidth,
        destHeight: that.canvasHeight,
        canvasId: 'myCanvas',
        success: function success(res) {
          wx.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success(res) {
              console.log(res, '保存')
            }
          })
        }
      });
    } else {
      wx.showToast({
        title: '请先选择图片',
        image: '../../static/img/error.png'
      })
    }
  }

分享图片

// 分享图片
  share() {
    let that = this
    if (that.data.previewImage) {

      wx.canvasToTempFilePath({
        x: 0,
        y: 0,
        width: that.canvasWidth,
        height: that.canvasWidth,
        destWidth: that.canvasWidth,
        destHeight: that.canvasHeight,
        canvasId: 'myCanvas',
        success: function success(res) {
          wx.showToast({
            icon: 'none',
            title: '长按图片分享',
            duration: 1500
          })
          setTimeout(
            () => {
              wx.previewImage({
                urls: [res.tempFilePath]
              })
            }, 1000)
        }
      })
    } else {
      wx.showToast({
        title: '请先选择图片',
        image: '../../static/img/error.png'
      })
    }
  }

原文链接：https://www.jianshu.com/p/1e54146b8a26

转自https://blog.csdn.net/qq_18976087/article/details/79095735

最近在做一个手机站，要求点击分享可以直接打开微信分享出去。而不是jiathis，share分享这种的点击出来二维码。在网上看了很多，都说APP能唤起微信，手机网页实现不了。也找了很多都不能直接唤起微信。

总结出来一个可以直接唤起微信的。适应手机qq浏览器和uc浏览器。

下面上代码，把这些直接放到要转发的页面里就可以了：

html部分：

<script src="mshare.js"></script>//引进mshare.js
<button data-mshare="0">点击弹出原生分享面板</button>
<button data-mshare="1">点击触发朋友圈分享</button>
<button data-mshare="2">点击触发发送给微信朋友</button>

js部分：

<script>
var mshare = new mShare({
    title: 'Lorem ipsum dolor sit.',
    url: 'http://m.ly.com',
    desc: 'Lorem ipsum dolor sit amet, consectetur adipisicing elit. Quaerat inventore minima voluptates.',
    img: 'http://placehold.it/150x150'
});
$('button').click(function () {
    // 1 ==> 朋友圈  2 ==> 朋友  0 ==> 直接弹出原生
    mshare.init(+$(this).data('mshare'));
});
</script>

/**
 * 此插件主要作用是在UC和QQ两个主流浏览器
 * 上面触发微信分享到朋友圈或发送给朋友的功能
 */
'use strict';
var UA = navigator.appVersion;
 
/**
 * 是否是 UC 浏览器
 */
var uc = UA.split('UCBrowser/').length > 1 ? 1 : 0;
 
/**
 * 判断 qq 浏览器
 * 然而qq浏览器分高低版本
 * 2 代表高版本
 * 1 代表低版本
 */
var qq = UA.split('MQQBrowser/').length > 1 ? 2 : 0;
 
/**
 * 是否是微信
 */
var wx = /micromessenger/i.test(UA);
 
/**
 * 浏览器版本
 */
var qqVs = qq ? parseFloat(UA.split('MQQBrowser/')[1]) : 0;
var ucVs = uc ? parseFloat(UA.split('UCBrowser/')[1]) : 0;
 
/**
 * 获取操作系统信息  iPhone(1)  Android(2)
 */
var os = (function () {
    var ua = navigator.userAgent;
 
    if (/iphone|ipod/i.test(ua)) {
        return 1;
    } else if (/android/i.test(ua)) {
        return 2;
    } else {
        return 0;
    }
}());
 
/**
 * qq浏览器下面 是否加载好了相应的api文件
 */
var qqBridgeLoaded = false;
 
// 进一步细化版本和平台判断
if ((qq && qqVs < 5.4 && os == 1) || (qq && qqVs < 5.3 && os == 1)) {
    qq = 0;
} else {
    if (qq && qqVs < 5.4 && os == 2) {
        qq = 1;
    } else {
        if (uc && ((ucVs < 10.2 && os == 1) || (ucVs < 9.7 && os == 2))) {
            uc = 0;
        }
    }
}
/**
 * qq浏览器下面 根据不同版本 加载对应的bridge
 * @method loadqqApi
 * @param  {Function} cb 回调函数
 */
function loadqqApi(cb) {
    // qq == 0 
    if (!qq) {
        return cb && cb();
    }
    var script = document.createElement('script');
    script.src = (+qq === 1) ? '//3gimg.qq.com/html5/js/qb.js' : '//jsapi.qq.com/get?api=app.share';
    /**
     * 需要等加载过 qq 的 bridge 脚本之后
     * 再去初始化分享组件
     */
    script.onload = function () {
        cb && cb();
    };
    document.body.appendChild(script);
}
/**
 * UC浏览器分享
 * @method ucShare
 */
function ucShare(config) {
    // ['title', 'content', 'url', 'platform', 'disablePlatform', 'source', 'htmlID']
    // 关于platform
    // ios: kWeixin || kWeixinFriend;
    // android: WechatFriends || WechatTimeline
    // uc 分享会直接使用截图
    var platform = '';
    var shareInfo = null;
    // 指定了分享类型
    if (config.type) {
        if (os == 2) {
            platform = config.type == 1 ? 'WechatTimeline' : 'WechatFriends';
        } else if (os == 1) {
            platform = config.type == 1 ? 'kWeixinFriend' : 'kWeixin';
        }
    }
    shareInfo = [config.title, config.desc, config.url, platform, '', '', ''];
    // android 
    if (window.ucweb) {
        ucweb.startRequest && ucweb.startRequest('shell.page_share', shareInfo);
        return;
    }
    if (window.ucbrowser) {
        ucbrowser.web_share && ucbrowser.web_share.apply(null, shareInfo);
        return;
    }
}
/**
 * qq 浏览器分享函数
 * @method qqShare
 */
function qqShare(config) {
    var type = config.type;
    //微信好友 1, 微信朋友圈 8
    type = type ? ((type == 1) ? 8 : 1) : '';
    var share = function () {
        var shareInfo = {
            'url': config.url,
            'title': config.title,
            'description': config.desc,
            'img_url': config.img,
            'img_title': config.title,
            'to_app': type,
            'cus_txt': ''
        };
        if (window.browser) {
            browser.app && browser.app.share(shareInfo);
        } else if (window.qb) {
            qb.share && qb.share(shareInfo);
        }
    };
    if (qqBridgeLoaded) {
        share();
    } else {
        loadqqApi(share);
    }
}
/**
 * 对外暴露的接口函数
 * @method mShare
 * @param  {Object} config 配置对象
 */
function mShare(config) {
    this.config = config;
    this.init = function (type) {
        if (typeof type != 'undefined') this.config.type = type;
        try {
            if (uc) {
                ucShare(this.config);
            } else if (qq && !wx) {
                qqShare(this.config);
            }
        } catch (e) {}
    }
}
// 预加载 qq bridge
loadqqApi(function () {
    qqBridgeLoaded = true;
});
if (typeof module === 'object' && module.exports) {
    module.exports = mShare;
} else {
    window.mShare = mShare;
}

通常在开发中，我们的APP中会使用到一些自己定义的字体，关于引用那部分就不细说了，网上百度一堆，下边说一个容易忽略的点。

在iOS中，使用字体，不是使用字体包的名称，而是需要导入包体在iOS中对应的名称，打印字体名称如下：

for (NSString *fontfamilyname in [UIFont familyNames]) { // font:'Avenir-Heavy

            NSLog(@"family:'%@'",fontfamilyname);

            for(NSString *fontName in [UIFont fontNamesForFamilyName:fontfamilyname])

            {

                NSLog(@"\tfont:'%@'",fontName);

            }

            NSLog(@"-------------");

}

对字体的使用

self.proNameLab.font = [UIFont fontWithName:@"Avenir-Heavy" size:13*ScaleSize];