近几年 TypeScript 和 JavaScript 一直在稳步发展。我们在过去写代码时养成了一些习惯，而有些习惯却没有什么意义。以下是我们都应该改正的 10 个坏习惯。

1.不使用 strict 模式

• 这种习惯看起来是什么样的

没有用严格模式编写 tsconfig.json。

{
  "compilerOptions": {
    "target": "ES2015",
    "module": "commonjs"
  }
}

• 应该怎样

只需启用 strict 模式即可：

{

  "compilerOptions": {

    "target": "ES2015",

    "module": "commonjs",

    "strict": true

  }

}

• 为什么会有这种坏习惯

在现有代码库中引入更严格的规则需要花费时间。

• 为什么不该这样做

更严格的规则使将来维护代码时更加容易，使你节省大量的时间。

2. 用 ||定义默认值

• 这种习惯看起来是什么样的

使用旧的 ||处理后备的默认值：

function createBlogPost (text: string, author: string, date?: Date) {

  return {

    text: text,

    author: author,

    date: date || new Date()

  }

}

function createBlogPost (text: string, author: string, date: Date = new Date())

  return {

    text: text,

    author: author,

    date: date

  }

}

async function loadProducts(): Promise<Product[]> {
  const response = await fetch('https://api.mysite.com/products')
  const products: any = await response.json()
  return products
}

async function loadProducts(): Promise<Product[]> {

  const response = await fetch('https://api.mysite.com/products')

  const products: unknown = await response.json()

  return products as Product[]

}

async function loadProducts(): Promise<Product[]> {

  const response = await fetch('https://api.mysite.com/products')

  const products: unknown = await response.json()

  return products as Product[]

}

function isArrayOfProducts (obj: unknown): obj is Product[] {

  return Array.isArray(obj) && obj.every(isProduct)

}



function isProduct (obj: unknown): obj is Product {

  return obj != null

    && typeof (obj as Product).id === 'string'

}



async function loadProducts(): Promise<Product[]> {

  const response = await fetch('https://api.mysite.com/products')

  const products: unknown = await response.json()

  if (!isArrayOfProducts(products)) {

    throw new TypeError('Received malformed products API response')

  }

  return products

}

interface User {

  id: string

  firstName: string

  lastName: string

  email: string

}



test('createEmailText returns text that greats the user by first name', () => {

  const user: User = {

    firstName: 'John'

  } as any

  

  expect(createEmailText(user)).toContain(user.firstName)

}

interface User {

  id: string

  firstName: string

  lastName: string

  email: string

}



class MockUser implements User {

  id = 'id'

  firstName = 'John'

  lastName = 'Doe'

  email = 'john@doe.com'

}



test('createEmailText returns text that greats the user by first name', () => {

  const user = new MockUser()



  expect(createEmailText(user)).toContain(user.firstName)

}

interface Product {

  id: string

  type: 'digital' | 'physical'

  weightInKg?: number

  sizeInMb?: number

}

interface Product {

  id: string

  type: 'digital' | 'physical'

}



interface DigitalProduct extends Product {

  type: 'digital'

  sizeInMb: number

}



interface PhysicalProduct extends Product {

  type: 'physical'

  weightInKg: number

}

function head<T> (arr: T[]): T | undefined {

  return arr[0]

}

function head<Element> (arr: Element[]): Element | undefined {

  return arr[0]

}

function createNewMessagesResponse (countOfNewMessages?: number) {

  if (countOfNewMessages) {

    return `You have ${countOfNewMessages} new messages`

  }

  return 'Error: Could not retrieve number of new messages'

}

function createNewMessagesResponse (countOfNewMessages?: number) {

  if (countOfNewMessages !== undefined) {

    return `You have ${countOfNewMessages} new messages`

  }

  return 'Error: Could not retrieve number of new messages'

}

function createNewMessagesResponse (countOfNewMessages?: number) {

  if (!!countOfNewMessages) {

    return `You have ${countOfNewMessages} new messages`

  }

  return 'Error: Could not retrieve number of new messages'

}

function createNewMessagesResponse (countOfNewMessages?: number) {

  if (countOfNewMessages !== undefined) {

    return `You have ${countOfNewMessages} new messages`

  }

  return 'Error: Could not retrieve number of new messages'

}

function createNewMessagesResponse (countOfNewMessages?: number) {

  if (countOfNewMessages != null) {

    return `You have ${countOfNewMessages} new messages`

  }

  return 'Error: Could not retrieve number of new messages'

}

function createNewMessagesResponse (countOfNewMessages?: number) {

  if (countOfNewMessages !== undefined) {

    return `You have ${countOfNewMessages} new messages`

  }

  return 'Error: Could not retrieve number of new messages'

}

• 不知道如何准确的定义出类型，TS 报错了，用 any 能解决，便用 any 了
• 觉得定义类型浪费时间，项目经理催的紧，工期紧张，any 更方便

;(<any>window).obj = {}(
  // 或
  window as any
).obj = {}

interface Window {
  obj: {}
}

interface Window {
  obj: {}
}

const a: {
  b: string
  c?: {
    d: string
  }
} = {
  b: "123",
}

console.log((<any>a).c.d) // 错误，这样访问会报错，应使用可选链
console.log(a.c!.d) // 错误，ts 不会将错误抛出，但实际访问也会报错

const a = {
  c: undefined,
}

const b = a?.c?.d

"use strict"

var _a$c

const a = {
  c: undefined,
}
const b =
  a === null || a === void 0
    ? void 0
    : (_a$c = a.c) === null || _a$c === void 0
    ? void 0
    : _a$c.d

const obj: {
  a: 1 | 2
  b: string | number
} = {
  a: 1,
  b: "1.2"
}

if (obj.a === 1) {
  const [left, right] = (obj.b as string).split(".")
}
// 如果你偷懒，那可能又变成了这样的情况
if (obj.a === 1) {
  const [left, right] = (obj.b as any).split(".")
}

const obj: {
  a: 1
  b: string
} | {
  a: 2
  b: number
} = {
  a: 1,
  b: "1.2"
}
// 你会发现这样定义了以后，不需要再次进行断言限定 obj.b 的范围
if (obj.a === 1) {
  const [left, right] = obj.b.split(".") // 校验通过
}

const { a, b } = props // 错误，a 和 b 的类型关系丢失

type X = xxxx // 某种类型
function check(params): params is X

interface Window {
    wx?: {
        xxxx: Function
    }
    webviewnative?: {
        xxxx: Function
    }
}

if (typeof window.wx !== 'undefined') {
    window.wx.xxxx()
} else {
    // not in wx
}

function checkIsWxNativeAPICanUse(win: Window): win is { wx: Exclude<Window['wx'], undefined> } & Window {

    return typeof window.wx !== 'undefined'

}

// 使用

if (checkIsWxNativeAPICanUse(window)) {

    window.wx.xxxx()

}

问题

在项目中,选择照片或拍照的功能很长见,由于我之前采用系统自带的UIimagePickViewController遇到一点问题:

1、使用拍照功能,进行截取时(allowEditing = YES)时,拍照完成的图片无法拖动,没有办法进行选择性的截取图片
2、如果使用选择相册功能,进入裁剪界面,图片是可以拖动的,唯独拍照之后进入裁剪界面无法拖动
3、微信头像更换拍照好像也无法拖动,初步推测可能使用的系统自带的裁剪界面
所以想来仔细研究一下UIImagePickViewController的属性和使用方法

UIImagePickViewController

UIImagePickerController是iOS系统提供的和系统的相册和相机交互的一个类,可以用来获取相册的照片,也可以调用系统的相机拍摄照片或者视频。该类的继承结构是:

UIImagePickerController-->UINavigationController-->UIViewController-->UIResponder-->NSObject

官方文档中对于该类的说明是:

该类只支持竖屏模式，为了保证该类被原样使用，它不支持子类，并且它的视图层次是私有的不能被修改，只支持自定义cameraOverlayView属性来展示更多信息以及和用户的交互。

由于该类继承自UINavgationController,所以在使用过程中一般实现UIImagePickerControllerDelegate和UINavigationControllerDelegate这两个代理，可以利用navgation的push 和pop操作自定义界面实现更复杂的交互效果。

下面具体分析该类的一些方法和属性.

UIImagePickViewController之常用属性

@property (nullable, nonatomic, weak) id <UINavigationControllerDelegate, UIImagePickerControllerDelegate> delegate;

该对象的代理需要实现UINavigationControllerDelegate和UIImagePickerControllerDelegate协议，nullable是xcode6.3之后引入的nullability annotations特性，主要用于在OC和swift之间的转换。这一特性主要包含两个新的类型注释nullable和nonnull，用于表示对象是否可以是NULL或nil

@property (nonatomic) UIImagePickerControllerSourceType sourceType; // default value is UIImagePickerControllerSourceTypePhotoLibrary.

sourceType用于指定要访问的系统的媒体类型。UIImagePickerControllerSourceType支持以下3种枚举类型，默认值是图片库

typedef NS_ENUM(NSInteger, UIImagePickerControllerSourceType) { UIImagePickerControllerSourceTypePhotoLibrary,//照片库模式。图像选取控制器以该模式显示时会浏览系统照片库的根目录。 UIImagePickerControllerSourceTypeCamera, //相机模式，图像选取控制器以该模式显示时可以进行拍照或摄像。 UIImagePickerControllerSourceTypeSavedPhotosAlbum //相机胶卷模式，图像选取控制器以该模式显示时会浏览相机胶卷目录。};

1、PhotoLibrary代表系统照片应用对应的相薄，包含照片流和其它自定义的相册
2、PhotosAlbum则对应系统照片应用的照片，包含用设备拍摄的所有照片流。
3、Camera则代表相机的摄像头。

@property (nonatomic, copy) NSArray<NSString *> *mediaTypes;

mediaTypes用于设置相机支持的功能，拍照或者是视频，返回值类型可以是kUTTypeMovie视频和kUTTypeImage拍照

1、kUTTypeMovie包含

const CFStringRef kUTTypeAudiovisualContent ;抽象的声音视频
const CFStringRef kUTTypeMovie ;抽象的媒体格式（声音和视频）
const CFStringRef kUTTypeVideo ;只有视频没有声音
const CFStringRef kUTTypeAudio ;只有声音没有视频
const CFStringRef kUTTypeQuickTimeMovie ;
const CFStringRef kUTTypeMPEG ;
const CFStringRef kUTTypeMPEG4 ;
const CFStringRef kUTTypeMP3 ;
const CFStringRef kUTTypeMPEG4Audio ;
const CFStringRef kUTTypeAppleProtectedMPEG4Audio;

2、kUTTypeImage包含

const CFStringRef kUTTypeImage ;抽象的图片类型
const CFStringRef kUTTypeJPEG ;
const CFStringRef kUTTypeJPEG2000 ;
const CFStringRef kUTTypeTIFF ;
const CFStringRef kUTTypePICT ;
const CFStringRef kUTTypeGIF ;
const CFStringRef kUTTypePNG ;
const CFStringRef kUTTypeQuickTimeImage ;
const CFStringRef kUTTypeAppleICNS const CFStringRef kUTTypeBMP;
const CFStringRef kUTTypeICO;

@property (nonatomic) BOOL showsCameraControls NS_AVAILABLE_IOS(3_1);
@property (nonatomic) BOOL allowsEditing NS_AVAILABLE_IOS(3_1); // replacement for -allowsImageEditing; default value is NO.
@property (nonatomic) BOOL allowsImageEditing NS_DEPRECATED_IOS(2_0, 3_1);

1、showsCameraControls用于指定拍照时下方的工具栏是否显示
2、allowImageEditing在iOS3.1就已废弃，取而代之的是allowEditing,
3、allowEditing表示拍完照片或者从相册选完照片后，是否跳转到编辑模式对图片裁剪，只有在showsCameraControls为YES时才有效果。

@property (nonatomic) UIImagePickerControllerCameraCaptureMode cameraCaptureMode NS_AVAILABLE_IOS(4_0); // default is UIImagePickerControllerCameraCaptureModePhoto
@property (nonatomic) UIImagePickerControllerCameraDevice cameraDevice NS_AVAILABLE_IOS(4_0); // default is UIImagePickerControllerCameraDeviceRear
@property (nonatomic) UIImagePickerControllerCameraFlashMode cameraFlashMode 
@property (nonatomic) CGAffineTransform cameraViewTransform NS_AVAILABLE_IOS(3_1); // set the transform of the preview view.
@property (nullable, nonatomic,strong) __kindof UIView *cameraOverlayView NS_AVAILABLE_IOS(3_1); // set a view to overlay the preview view.

当sourceType是camera的时候，这几个属性有效，否则抛出异常。

· cameraCaptureMode捕捉模式指定的是相机是拍摄照片还是视频,它的枚举类型如下:

NS_ENUM(NSInteger, UIImagePickerControllerCameraCaptureMode) { 
    UIImagePickerControllerCameraCaptureModePhoto,//photo 
    UIImagePickerControllerCameraCaptureModeVideo//video
};

· cameraDevice指定拍摄的摄像头位置，是使用前置摄像头还是后置摄像头,它的枚举类型有:

typedef NS_ENUM(NSInteger, UIImagePickerControllerCameraDevice) { 
    UIImagePickerControllerCameraDeviceRear,//后摄像头(默认) 
    UIImagePickerControllerCameraDeviceFront//前摄像头
};

· cameraFlashMode用于指定闪光灯模式，它的枚举类型如下:

typedef NS_ENUM(NSInteger, UIImagePickerControllerCameraFlashMode) { 
    UIImagePickerControllerCameraFlashModeOff = -1,//关闭闪关灯 
    UIImagePickerControllerCameraFlashModeAuto = 0,//自动 
    UIImagePickerControllerCameraFlashModeOn = 1//开启闪关灯
};

· cameraViewTransform该结构体可以用于指定拍摄时View的一些形变属性，如旋转缩放等。当showsCameraControls为NO，系统的工具栏隐藏时，我们可以自定义背景View赋值给cameraOverlayView添加到拍摄时的预览视图之上。

@property(nonatomic) NSTimeInterval videoMaximumDuration NS_AVAILABLE_IOS(3_1); // default value is 10 minutes.
@property(nonatomic) UIImagePickerControllerQualityType videoQuality NS_AVAILABLE_IOS(3_1);

· videoMaximumDuration用于设置视频拍摄模式下最大拍摄时长，默认值是10分钟。
· videoQuality表示拍摄的视频质量设置，默认是Medium即表示中等质量。 videoQuality支持的枚举类型如下:

typedef NS_ENUM(NSInteger, UIImagePickerControllerQualityType) { 
    UIImagePickerControllerQualityTypeHigh = 0, // 高清模式 
    UIImagePickerControllerQualityTypeMedium = 1, //中等质量，适于WIFI传播
    UIImagePickerControllerQualityTypeLow = 2, //低等质量，适于蜂窝网络传输 
    UIImagePickerControllerQualityType640x480 NS_ENUM_AVAILABLE_IOS(4_0) = 3, // VGA 质量 
    UIImagePickerControllerQualityTypeIFrame1280x720 NS_ENUM_AVAILABLE_IOS(5_0) = 4,//1280*720的分辨率 
    UIImagePickerControllerQualityTypeIFrame960x540 NS_ENUM_AVAILABLE_IOS(5_0) = 5,//960*540分辨率
};

UIImagePickViewController之类方法

@interface UIImagePickerController : UINavigationController <NSCoding>
+ (BOOL)isSourceTypeAvailable:(UIImagePickerControllerSourceType)sourceType; // returns YES if source is available (i.e. camera present)
+ (nullable NSArray<NSString *> *)availableMediaTypesForSourceType:(UIImagePickerControllerSourceType)sourceType; // returns array of available media types (i.e. kUTTypeImage)
+ (BOOL)isCameraDeviceAvailable:(UIImagePickerControllerCameraDevice)cameraDevice NS_AVAILABLE_IOS(4_0); // returns YES if camera device is available 
+ (BOOL)isFlashAvailableForCameraDevice:(UIImagePickerControllerCameraDevice)cameraDevice NS_AVAILABLE_IOS(4_0); // returns YES if camera device supports flash and torch.
+ (nullable NSArray<NSNumber *> *)availableCaptureModesForCameraDevice:(UIImagePickerControllerCameraDevice)cameraDevice NS_AVAILABLE_IOS(4_0);

isSourceTypeAvailable用于判断当前设备是否支持指定的sourceType，可以是照片库/相册/相机.
isCameraDeviceAvailable判断当前设备是否支持前置摄像头或者后置摄像头
isFlashAvailableForCameraDevice是否支持前置摄像头闪光灯或者后置摄像头闪光灯
availableMediaTypesForSourceType方法返回所特定的媒体如相册/图片库/相机所支持的媒体类型数组,元素值可以是kUTTypeImage类型或者kUTTypeMovie类型的静态字符串，所以是NSString类型的数组
availableCaptureModesForCameraDevice返回特定的摄像头(前置摄像头/后置摄像头)所支持的拍摄模式数值数组，元素值可以是UIImagePickerControllerCameraCaptureMode枚举里面的video或者photo,所以是NSNumber类型的数组

UIImagePickViewController之对象方法

- (void)takePicture NS_AVAILABLE_IOS(3_1);
- (BOOL)startVideoCapture NS_AVAILABLE_IOS(4_0);
- (void)stopVideoCapture NS_AVAILABLE_IOS(4_0);

1、takePicture可以用来实现照片的连续拍摄，需要自己自定义拍摄的背景视图来赋值给cameraOverlayView，结合自定义overlayView实现多张照片的采集，在收到代理的didFinishPickingMediaWithInfo方法之后可以启动额外的捕捉。
2、startVideoCapture用来判断当前是否可以开始录制视频，当视频正在拍摄中，设备不支持视频拍摄，磁盘空间不足等情况，该方法会返回NO.该方法结合自定义overlayView可以拍摄多部视频
3、stopVideoCapture当你调用此方法停止视频拍摄时，它会调用代理的imagePickerController：didFinishPickingMediaWithInfo：方法

UIImagePickViewController之代理方法

@protocol UIImagePickerControllerDelegate<NSObject>
@optional
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingImage:(UIImage *)image editingInfo:(nullable NSDictionary<NSString *,id> *)editingInfo NS_DEPRECATED_IOS(2_0, 3_0);
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary<NSString *,id> *)info;
- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker;
@end

1、imagePickerController:didFinishPickingImage:editingInfo:在iOS3.0中已废弃，不再使用。
2、当用户取消选取的内容时会调用DidCancel方法，默认实现销毁弹出的视图。
3、当完成内容的选取时会调用didFinishPickingMediaWithInfo方法，默认info字典的key值可以是以下类型:

UIKIT_EXTERN NSString *const UIImagePickerControllerMediaType; //指定用户选择的媒体类型
UIKIT_EXTERN NSString *const UIImagePickerControllerOriginalImage; // 原始图片
UIKIT_EXTERN NSString *const UIImagePickerControllerEditedImage; // 修改后的图片
UIKIT_EXTERN NSString *const UIImagePickerControllerCropRect; // 裁剪尺寸
UIKIT_EXTERN NSString *const UIImagePickerControllerMediaURL; // 媒体的URL
UIKIT_EXTERN NSString *const UIImagePickerControllerReferenceURL NS_AVAILABLE_IOS(4_1); // 原件的URL
UIKIT_EXTERN NSString *const UIImagePickerControllerMediaMetadata //当数据来源是相机的时候获取到的静态图像元数据，可以使用phtoho框架进行处理

UIImagePickViewController之C语言函数(保存图片或视频)

UIKIT_EXTERN void UIImageWriteToSavedPhotosAlbum(UIImage *image, __nullable id completionTarget, __nullable SEL completionSelector, void * __nullable contextInfo);
UIKIT_EXTERN BOOL UIVideoAtPathIsCompatibleWithSavedPhotosAlbum(NSString *videoPath) NS_AVAILABLE_IOS(3_1);
UIKIT_EXTERN void UISaveVideoAtPathToSavedPhotosAlbum(NSString *videoPath, __nullable id completionTarget, __nullable SEL completionSelector, void * __nullable contextInfo) NS_AVAILABLE_IOS(3_1);

1、UIImageWriteToSavedPhotosAlbum用来保存照片到相册，seletor应该设置为- (void)image:(UIImage )image didFinishSavingWithError:(NSError )error contextInfo:(void )contextInfo;当照片保存到相册完成时，会调用该方法通知你。
2、UIVideoAtPathIsCompatibleWithSavedPhotosAlbum会返回布尔类型的值判断该路径下的视频能否保存到相册，视频需要先存储到沙盒文件再保存到相册，而照片是可以直接从代理完成的回调info字典里面获取到。
3、UISaveVideoAtPathToSavedPhotosAlbum用来保存视频到相册，seletor应该设置为- (void)video:(NSString )videoPath didFinishSavingWithError:(NSError )error contextInfo:(void )contextInfo;当视频保存到相册或出错时会调用该方法通知你。
这三个方法一般是在代理的完成方法didFinishPickingMediaWithInfo里面配合使用。
以上便是系统UIImagePickViewController的所有属性和方法的简单介绍

问题解决方案

由于使用设置allowEditing = YES属性后,开启摄像头拍照后直接进入系统自定义的裁剪界面,但是在这个界面,从摄像头拍摄过来的照片无法拖动裁剪,仅仅从相册选择过来的照片是可以拖动进行裁剪的,那么我们就决定裁剪界面不使用系统自带的,而自定义一个裁剪界面.

在UIImagePickViewController的代理方法里

#pragma UIImagePickerController Delegate
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
  UIImage *portraitImg = [info objectForKey:@"UIImagePickerControllerOriginalImage"]; 
  YYImageClipViewController *imgClipVC = [[YYImageClipViewController alloc] initWithImage:portraitImg cropFrame:CGRectMake(0, 100.0f, self.view.frame.size.width, self.view.frame.size.width) limitScaleRatio:3.0]; 
  imgClipVC.delegate = self;
  [picker pushViewController:imgClipVC animated:NO];
}

- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker
{ 
  [picker dismissViewControllerAnimated:YES completion:nil];
}

HZImageCropperViewController是我自定义的一个裁剪界面,通过这个控制器的两个代理方法,得到裁剪后的照片

- (void)imageClip:(YYImageClipViewController *)clipViewController didFinished:(UIImage *)editedImage 
{ 
  //保存图片
  NSString *imageFilePath = [UIImage saveImage:editedImage]; 
  //上传七牛服务器 
  [self upImageFilePath:imageFilePath]; 
  //隐藏裁剪界面 
  [clipViewController dismissViewControllerAnimated:YES completion:nil];
}

- (void)imageClipDidCancel:(YYImageClipViewController *)clipViewController
{
   [clipViewController dismissViewControllerAnimated:YES completion:nil];
}

下面附上一个demo,里面包含裁剪界面的源代码,可供大家参考
自定义裁剪界面demo

转自：https://www.jianshu.com/p/9474ca73e269

逻辑图

终端代码及源码

clang 命令行及源码.zip

一、我们要做什么

我们的目的是想要通过TypeScript的类型声明式语法，编程实现一个斐波那契数列算法。换句话说，类似于用现有的机器码到指令集、二进制到十进制、汇编语言到高级编程语言的过程，让类型定义语法也可以实现编程。

最终我们要实现的斐波那契数列代码是这样的？

const fib = (n: number): number => n <= 1 ? n : fib(n - 1) + fib(n - 2);

for (let i = 0; i < 10; i++) {
  console.log(i, fib(i));
}

运行结果如下：

程序完全没问题，完结撒花！

开玩笑的，上面是只一个用了TypeScript类型定义的JavaScript写法，我们其实真正想这样做↓↓↓, 也就是使用TS Type解决FIbonacci

import { Fib, Add } from './fib-type';

type one = Fib<1>;
type zero = Fib<0>;
type Two = Add<one, one>;
type Five = Add<Two, Add<Two, one>>;
type Fib5 = Fib<Five>;
type Fib9 = Fib<9>;
type r0 = Fib<Zero>; // type r0= 0
type r1 = Fib<One>; // type r1 = 1
type r2 = Fib<Two>; // type r2 = 1
type r3 = Fib<3>; // type r3 = 2
type r4 = Fib<4>; // type r4 = 3
type r5 = Fib<5>; // type r5 = 5
type r6 = Fib<6>; // type r6 = 8
type r9 = Fib<9>; // type r9 = 34
type sum = Add<r9, r6>; // type sum = 42

二、我们该怎么做

要想实现斐波那契数列，参考一开始的代码，有基本的比较, 加法, 循环语法, 所以我们也需要使用类型系统依次实现这三种功能

2.1 加法的实现

为了实现加法, 需要先实现一些工具类型

// 元组长度
type Length<T extends any[]> = T['length'];
type one = 1

// 使用extends实现数字相等的比较
type a111 = 0 extends one ? true : false // type a111 = false
type a112 = 1 extends one ? true : false // type a112 = true

range的实现是递归实现的

// 伪代码
function range(n, list=[]){
  if(n<=0) return list.length
  return range(n-1, [1, ...list])
}

TypeScript的限制, 没有循环, 只能用递归代替循环, 后面会有几个类似的写法, 记住一点：递归有几个出口, 对象就有几个 key, 每个 key 就是一个条件

// 创建指定长度的元组, 用第二个参数携带返回值
type Range<T extends Number = 0, P extends any[] = []> = {
  0: Range<T, [any, ...P]>;
  1: P;
}[Length<P> extends T ? 1 : 0];

// 拼接两个元组
type Concat<T extends any[], P extends any[]> = [...T, ...P];

type t1 = Range<3>;
// type t1 = [any, any, any]

type Zero = Length<Range<0>>;
//   type Zero = 0
type Ten = Length<Range<10>>;
// type Ten = 10

type Five = Length<Range<5>>;
// type Five = 5

type One = Length<Range<1>>;

有了上面的工具语法，那么实现加法就比较容易了, 只需要求两个元组合并后的长度

type Add<T extends number, P extends number> = Length<
    Concat<Range<T>, Range<P>>
  >;
  type Two = Add<One, One>;
  //   type Two = 2
  type Three = Add<One, Two>;
  // type Three = 3

有了加法，该如何实现减法呢？一般减法和除法都比加法难, 所以我们需要更多的工具类型函数

2.2 工具函数

2.2.1 实现一些基本工具类型

• Shift：删除第一个元素
• Append：在元组末尾插入元素
• IsEmpty / NotEmpty：判断列表为空

// 去除元组第一个元素 [1,2,3] -> [2,3]
type Shift<T extends any[]> = ((...t: T) => any) extends (
  _: any,
  ...Shift: infer P
) => any
  ? P
  : [];

type pp = Shift<[number, boolean,string, Object]>
// type pp = [boolean, string, Object]

// 向元组中追加
type Append<T extends any[], E = any> = [...T, E];
type IsEmpty<T extends any[]> = Length<T> extends 0 ? true : false;
type NotEmpty<T extends any[]> = IsEmpty<T> extends true ? false : true;
type t4 = IsEmpty<Range<0>>;
// type t4 = true

type t5 = IsEmpty<Range<1>>;
// type t5 = false

// 逻辑操作
type And<T extends boolean, P extends boolean> = T extends false
  ? false
  : P extends false
  ? false
  : true;
type t6 = And<true, true>;
// type t6 = true

type t7 = And<true, false>;
// type t7 = false

type t8 = And<false, false>;
// type t8 = false

type t9 = And<false, true>;
// type t9 = false

function dfs (a, b){
    if(a.length && b.length){
        a.pop()
        b.pop()
        return dfs(a,b)
    }else if(a.length){
        a >= b
    }else if (b.length){
        b > a
    }
}

// 元组的小于等于   T <= P, 同时去除一个元素, 长度先到0的比较小
type LessEqList<T extends any[], P extends any[]> = {
  0: LessEqList<Shift<T>, Shift<P>>;
  1: true;
  2: false;
}[And<NotEmpty<T>, NotEmpty<P>> extends true
  ? 0
  : IsEmpty<T> extends true
  ? 1
  : 2];


// 数字的小于等于
type LessEq<T extends number, P extends number> = LessEqList<Range<T>, Range<P>>;

type t10 = LessEq<Zero, One>;
// type t10 = true
type t11 = LessEq<One, Zero>;
// type t11 = false

type t12 = LessEq<One, One>;
// type t12 = true

// 伪代码
const a = [1, 2, 3];
const b = [4, 5];
const c = [];
while (b.length !== a.length) {
  a.pop();
  c.push(1);
}// c.length === a.length - b.lengthconsole.log(c.length);

// 元组的减法 T - P, 同时去除一个元素, 长度到0时, 剩下的就是结果, 这里使用第三个参数来携带结果, 每次做一次减法, 向第三个列表里面追加
type SubList<T extends any[], P extends any[], R extends any[] = []> = {
  0: Length<R>;
  1: SubList<Shift<T>, P, Apped<R>>;
}[Length<T> extends Length<P> ? 0 : 1];
type t13 = SubList<Range<10>, Range<5>>;
// type t13 = 5

// 集合大小不能为负数, 默认大减小
// 数字的减法
type Sub<T extends number, P extends number> = {
  0: Sub<P, T>;
  1: SubList<Range<T>, Range<P>>;
}[LessEq<T, P> extends true ? 0 : 1];

type t14 = Sub<One, Zero>;
//   type t14 = 1
type t15 = Sub<Ten, Five>;
// type t15 = 5

const fib = (n: number): number => n <= 1 ? n : fib(n - 1) + fib(n - 2);

export type Fib<T extends number> = {
  0: T;
  1: Add<Fib<Sub<T, One>>, Fib<Sub<T, Two>>>;
}[LessEq<T, One> extends true ? 0 : 1];

type r0 = Fib<Zero>;
// type r10= 0
type r1 = Fib<One>;
// type r1 = 1

type r2 = Fib<Two>;
// type r2 = 1

type r3 = Fib<3>;
// type r3 = 2

type r4 = Fib<4>;
// type r4 = 3

type r5 = Fib<5>;
//type r5 = 5

type r6 = Fib<6>;
//   type r6 = 8

ts作为一门新技术，这两年是越来越火，经过了一段时间的学习和理解之后，写了这篇文章，通过记录ts的核心知识点来带大家轻松掌握typescript，希望能够打动屏幕面前的你。

Typescript基础语法

TypeScript支持与JavaScript几乎相同的数据类型，此外还提供了实用的枚举类型方便我们使用。接下来我们简单介绍一下这几种类型的用法.

基础类型

// 布尔类型
let isFlag:boolean = true

// 数值类型
let myNumber:number = 24

// 字符串类型
let str:string = 'ykk'

// 数组类型, 有两种表示方式,第一种可以在元素类型后面接上[]，表示由此类型元素组成的一个数组
let arr:number[] = [1,2,3]
//当数组存在不同类型时
let arr1: (number | string)[] = [1, '2', 3]

// 数组类型, 使用数组泛型(有关泛型后面会详细分析)
let arr:Array<number> = [4,5,6]

// 元组类型, 允许表示一个已知元素数量和类型的数组，各元素的类型不必相同
let yuan: [string, number];
// 初始化yuan
yuan = ['yuan', 12]; // 正确
yuan = [12, 'yuan']; // 错误

// 枚举类型, 可以为一组数值赋予友好的名字
enum ActionType { online, offline, deleted }
let action:ActionType = ActionType.offline    // 1

// any, 表示任意类型, 可以绕过类型检查器对这些值进行检查
let color:any = 1
color = 'red'

// void类型, 当一个函数没有返回值时，通常会设置其返回值类型是 void
function getName(): void {
    console.log("This is my name");
}

// object类型, 表示非原始类型，也就是除number，string，boolean，symbol，null或undefined之外的类型
let obj:object;
obj = {num: 1}

// 对象类型也可以写成
const t = {
    name:string,
    age:number
} = {
    name:'ykk',
    age:18
}

// 函数类型也属于一种对象类型(该实例返回值必须是number类型)
const getTt:() => number = () => {
    return 123;
}

//never类型(永远不会执行never之后的逻辑)
function errorEmitter(): never {
    throw new Error();
    console.log(123)
}

接口（Interface）

interface Person {
    name: string;
    age: number;
    phone: number;
}

let man:Person = {
    name: 'ykk',
    age: 18,
    phone: 13711111111
}

类型检查器不会去检查属性的顺序，只要相应的属性存在并且类型也是对的就可以。其次我们还可以定义可选属性和只读属性。 可选属性表示了接口里的某些属性不是必需的,所以可以定义也可以不定义。·可读属性·使得接口中的某些属性只能读取而不能赋值,如下：

interface Person {
  name: string;
  age?: number;
  readonly phone: number;
}

在实际场景中, 我们往往还会遇到不确定属性名和属性值类型的情况, 这个时候我们可以利用索引签名来设置额外的属性和类型, 如下：

interface Person {
  name: string;
  [propName: string]: any; //这里表示除了有name之外还可以有其他的任何属性，但是属性名必须是string类型，属性值任意类型都可以
}

当然接口也可以进行继承

//此时human这个interface就拥有Person的所有属性，并且在调用的时候也必须满足Proson的要求，否则就会报错
interface human extends Person {
    weight:55
}

类

和js的class一致, typescript的类有公共(public)，私有(private)与受保护(protected)的访问类型。

public 在TypeScript里，成员都默认为 public,表示允许它在定义类的外部被调用


private 表示它能在定义的类内使用，不能在该类的外部使用


protected 和private类似, 但是protected允许在类内及继承的子类中使用

class Person {
        public name:string = 'ykk';
        private age:number = 18;
        protected weight:number = 55;
        constructor(){

        }
    }
    
    class Man extends Person {
        public say(){
            return this.weight
        }
    }
    
    let p = new Person()
    let m = new Man()
    console.log(p.name) //ykk
    console.log(p.age) //报错age是private属性
    console.log(m.say()) //55

class Person {
    private _food: string = 'apple'
    get food() {
        return this._food
    }
    set food(name: string) {
        this._food = name
    }
}
let p = new Person()
console.log(p.food) //apple
p.food="cookie" //这里重新设置food

class Demo {
    private static instance: Demo;
    peivate contructor(public name:string){}
    
    static getInstance(){
        if(!this.instance){
            this.instance = new Demo('ykk')
        }
        return this.instance;
    }
}

const demo1 = Demo.getInstance();
const demo2 = Demo.getInstance();
console.log(demo1.name)
console.log(demo2.name)

abstract class MyAbstract {
    constructor(public name: string) {}
    say(): void {
        console.log('say name: ' + this.name);
    }
    abstract sayBye(): void; // 必须在派生类中实现
}

class SubMyAbstract extends MyAbstract {
    constructor() {
        super('ykk'); // 在派生类的构造函数中必须调用 super()
    }
    sayBye(): void {
        console.log('bye');
    }
    getOther(): void {
        console.log('loading...');
    }
}

let department: MyAbstract; // 允许创建一个对抽象类型的引用
department = new SubMyAbstract(); // 允许对一个抽象子类进行实例化和赋值
department.say();
department.sayBye();

department = new MyAbstract(); // 错误: 不能创建一个抽象类的实例
department.getOther(); // 错误: 方法在声明的抽象类中不存在

interface person1 {
  name: string;
  age: number;
}

interface person2 {
  hby: string;
  age: number;
}
let man：person1 | person2

let man：person1 | person2;
man = {
    name: 'ykk',
    age: 18,
    hby: 'basketball'
}
//使用as直接断言，告诉ts在哪里去找
if((me as person1).name) {
  console.log((me as person1).name); 
}

if((me as person1).name) {
  console.log((me as person2).hby); 
}
//使用in
  if(('name' in me)) {
    console.log(me.name); 
  }
  
  if('hby' in me) {
    console.log(me.hby); 
  }
  //使用typeof
 function add(one:number|string,two:number|string){
     if(typeof one=="string"||typeof two=="string"){
         retrun `${one}${two}`
     }
     retrun one+two
 }
 //使用instanceof
  class a{
      num:1
  }
function b(obj:object|a){
    if(obj instanceof a){
        retrun obj.num
    }
}

//定义是用尖括号表示一个变量
function iSay<T>(arg: T): T {
    return arg;
}
// 调用的时候去声明类型
let come = iSay<number>(123);

//传入一个数组
function say<T>(arr:T[]){
    ...
};
say<number>([11,22,33]);

//传入多个泛型
function say<T, F>(name:T, age:F){
    ...
};
say<string, number>('ykk', 18);

class say<T>{
    constructor(name:T){
        ...
    }
}
var t = new say<string>("1")

class say<T extends number|string>{
    constructor(one:T){
        ...
    }
}
var t = new say<string>("1") //这时候表示泛型只能是number类型或者string类型其中的一种，否则会报错

    name:string,
    age:number,
    get:boolean
}
var p = {
    name:'ykk',
    age:18,
    get:false
}
function add<T extends keyof persons>(key:T):persons[T]{
    return p[key]
}
//如此一来我们便能知道返回值的准确类型了
var p1 = add('name')
console.log(p1) //ykk

namespace Main{
    class circle {
        ...
    }
    
    class rect {
        ...
    }
    
    //如果想要导出给外部使用，需要导出
    export class san{
        ...
    }
}
//这样在全局只会有一个Main供我们使用了

//定义一个全局类型, 并编写相应的逻辑让ts识别相应的js语法
declare var superagent;
...

在做socket编程时，如果是做tcp连接，那就不可避免的会遇到粘包与半包的问题。

粘包 就是多组数据被一并接收了,粘在了一起，无法做划分；

半包 就是有数据接收不完整，无法处理。

要解决粘包、半包的问题，一般在设计数据(消息)格式时会约定好一个字段专门用于描述数据包的长度，这样就使数据有了边界，依靠这个边界，就能把每组数据划分出来，数据不完整时也能获知数据的缺失。

(当然也可以把数据设计成定长数据，但这样不够灵活；或者用\n,\r这类字符作为数据划分依据，但不直观、不明确，同时也不灵活)

举个栗子：

消息＝消息头＋消息体。消息头用于描述消息本身的基本信息，消息体则为消息的具体内容

如上图所示，假如我们的一个消息是这么定义的

消息头 ＝ msgId(4B)+version(2B)+len(4B),共占用10字节

消息体 =  len中描述的16字节长

所以这条消息的长度就是 26字节

可以看到，要想知道一条完整数据的边界，关键就是消息头中的len字段

假如我们现在接收到的数据是这样的：

这个情况下即包含了粘包，也出现了半包的情况，三个数据包粘在了一起，最后一个数据包没有接收完全，出现了半包的情况，看看代码如何处理

- (void)onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag 
{ 
  while (_readBuf.length >= 10)//因为头部固定10个字节，数据长度至少要大于10个字节，我们才能得到完整的消息描述信息 
  { 
    NSData *head = [_readBuf subdataWithRange:NSMakeRange(0, 10)];//取得头部数据 
    NSData *lengthData = [head subdataWithRange:NSMakeRange(6, 4)];//取得长度数据 
    NSInteger length = [[[NSString alloc] initWithData:lengthData encoding:NSUTF8StringEncoding] integerValue];//得出内容长度 
    NSInteger complateDataLength = length + 10;//算出一个包完整的长度(内容长度＋头长度) 
    if (_readBuf.length >= complateDataLength)//如果缓存中数据够一个整包的长度 
    { 
      NSData *data = [_readBuf subdataWithRange:NSMakeRange(0, complateDataLength)];//截取一个包的长度(处理粘包) 
      [self handleTcpResponseData:data];//处理包数据 
      //从缓存中截掉处理完的数据,继续循环 
      _readBuf = [NSMutableData dataWithData:[_readBuf subdataWithRange:NSMakeRange(complateDataLength, _readBuf.length - complateDataLength)]]; 
    } 
    else//如果缓存中的数据长度不够一个包的长度，则包不完整(处理半包，继续读取) 
    { 
      [_socket readDataWithTimeout:-1 buffer:_readBuf bufferOffset:_readBuf.length tag:0];//继续读取数据 
      return; 
    } 
  } 
  //缓存中数据都处理完了，继续读取新数据 
  [_socket readDataWithTimeout:-1 buffer:_readBuf bufferOffset:_readBuf.length tag:0];//继续读取数据 
}

摘自：https://www.jb51.net/article/105278.htm

Socket的基本概念

1.定义

网络上两个程序通过一个双向通信连接实现数据交互，这种双向通信的连接叫做Socket（套接字）。

2.本质

网络模型中应用层与TCP/IP协议族通信的中间软件抽象层，是它的一组编程接口（API），也即对TCP/IP的封装。TCP/IP也要提供可供程序员做网络开发所用的接口，即Socket编程接口。

3.要素

Socket是网络通信的基石，是支持TCP/IP协议的网络通信的基本操作单元，包含进行网络通信的必须的五种信息：

• 连接使用的协议
• 本地主机的IP地址
• 本地进程的协议端口
• 远程主机的IP地址
• 远程进程的协议端口

1. 数据流方式

- (IBAction)connectToServer:(id)sender {
    // 1.与服务器通过三次握手建立连接
    NSString *host = @"192.168.1.58";
    int port = 1212;
    
    //创建一个socket对象
    _socket = [[GCDAsyncSocket alloc] initWithDelegate:self
                                         delegateQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)];
    
    NSError *error = nil;
    
    // 开始连接
    [_socket connectToHost:host
                    onPort:port
                     error:&error];
    
    if (error) {
        NSLog(@"%@",error);
    }
}


#pragma mark - Socket代理方法
// 连接成功
- (void)socket:(GCDAsyncSocket *)sock
didConnectToHost:(NSString *)host
          port:(uint16_t)port {
    NSLog(@"%s",__func__);
}


// 断开连接
- (void)socketDidDisconnect:(GCDAsyncSocket *)sock
                  withError:(NSError *)err {
    if (err) {
        NSLog(@"连接失败");
    } else {
        NSLog(@"正常断开");
    }
}


// 发送数据
- (void)socket:(GCDAsyncSocket *)sock
didWriteDataWithTag:(long)tag {
    
    NSLog(@"%s",__func__);
    
    //发送完数据手动读取，-1不设置超时
    [sock readDataWithTimeout:-1
                          tag:tag];
}

// 读取数据
-(void)socket:(GCDAsyncSocket *)sock
  didReadData:(NSData *)data
      withTag:(long)tag {
    
    NSString *receiverStr = [[NSString alloc] initWithData:data
                                                  encoding:NSUTF8StringEncoding];
    
    NSLog(@"%s %@",__func__,receiverStr);
}

2.基于第三方开源库CocoaAsyncSocket

2.1客户端通过地址和端口号与服务端建立Socket连接，并写入相关数据。

- (void)connectToServerWithCommand:(NSString *)command
{
    _socket = [[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)];
    [_socket setUserData:command];
    
    NSError *error = nil;
    [_socket connectToHost:WIFI_DIRECT_HOST onPort:WIFI_DIRECT_PORT error:&error];
    if (error) {
        NSLog(@"__connect error:%@",error.userInfo);
    }
    
    [_socket writeData:[command dataUsingEncoding:NSUTF8StringEncoding] withTimeout:10.0f tag:6];
}

2.2 实现CocoaAsyncSocket的代理方法

#pragma mark - Socket Delegate

- (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(uint16_t)port
{
    NSLog(@"Socket连接成功：%s",__func__);
}

-(void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)err{
    if (err) {
        NSLog(@"连接失败");
    }else{
        NSLog(@"正常断开");
    }
    
    if ([sock.userData isEqualToString:[NSString stringWithFormat:@"%d",SOCKET_CONNECT_SERVER]])
    {
        //服务器掉线 重新连接
        [self connectToServerWithCommand:@"battery"];
    }else
    {
        return;
    }
}

-(void)socket:(GCDAsyncSocket *)sock didWriteDataWithTag:(long)tag {
    NSLog(@"数据发送成功：%s",__func__);
    //发送完数据手动读取，-1不设置超时
    [sock readDataWithTimeout:-1 tag:tag];
}

-(void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag {
    NSString *receiverStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
    NSLog(@"读取数据：%s %@",__func__,receiverStr);
}

摘自：https://www.jianshu.com/p/8e599ca5dfe8

WebSocket是什么

WebSocket协议是 基于TCP 的一种网络协议。
它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。

WebSocket基本原理

帧协议：

0                   1                   2                   3
      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
     +-+-+-+-+-------+-+-------------+-------------------------------+
     |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
     |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
     |N|V|V|V|       |S|             |   (if payload len==126/127)   |
     | |1|2|3|       |K|             |                               |
     +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
     |     Extended payload length continued, if payload len == 127  |
     + - - - - - - - - - - - - - - - +-------------------------------+
     |                               |Masking-key, if MASK set to 1  |
     +-------------------------------+-------------------------------+
     | Masking-key (continued)       |          Payload Data         |
     +-------------------------------- - - - - - - - - - - - - - - - +
     :                     Payload Data continued ...                :
     + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
     |                     Payload Data continued ...                |
     +---------------------------------------------------------------+

• fin（1 bit）：指示该帧是否构成该消息的最终帧。大多数情况下，消息适合于一个单一的帧，这一点总是默认设置的。实验表明，Firefox 在 32K 之后创建了第二个帧。

• rsv1，rsv2，rsv3（1 bit each）：必须为0，除非扩展里协商定义了非零值的含义。如果收到一个非零值，并且协商的扩展中没有一个定义这个非零值的含义，那么接收端必须抛出失败连接。

• opcode（4bits）：展示了帧表示什么。以下值目前正在使用：
  0x00：这个帧继续前面的有效载荷。
  0x01：此帧包含文本数据。
  0x02：这个帧包含二进制数据。
  0x08：这个帧终止连接。
  0x09：这个帧是一个 ping 。
  0x0a：这个帧是一个 pong 。
  （正如你所看到的，有足够的值未被使用，它们已被保留供将来使用）。
• payload：最可能被掩盖的实际数据。它的长度是 payload_len 的长度。
• masking-key（32 bits）：从客户端发送到服务器的所有帧都被帧中包含的 32 位值掩盖。
• 0-125 表示有效载荷的长度。 126 表示以下两个字节表示长度，127 表示接下来的 8 个字节表示长度。所以有效负载的长度在 〜7bit，16bit 和 64bit 括号内。
• payload_len（7 bits）：有效载荷的长度。 WebSocket 的帧有以下长度括号：
• mask（1 bit）：指示连接是否掩盖。就目前而言，从客户端到服务器的每条消息都必须掩盖，如果规范没有掩盖，规范就会终止连接。

其他特点包括：
（1）建立在 TCP 协议之上，服务器端的实现比较容易。
（2）与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。

要求服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息。(也可以采用HTTP/2)

iOS端实现WebSocket连接的参考方案

SocketRocket

SocketRocket是facebook封装的websocket开源库，采用纯Objective-C编写。
使用者需要自己实现心跳机制，以及适配断网重连等情况。

SocketIO

SocketIO将WebSocket、AJAX和其它的通信方式全部封装成了统一的通信接口，也就是说，我们在使用SocketIO时，不用担心兼容问题，底层会自动选用最佳的通信方式。因此说，WebSocket是SocketIO的一个子集。

前言

随着时代的发展，业内曾经提出过很多性能优化相关的标准和规范，从最初2007年雅虎提出34条军规，到2020年google开始推广Web Vitals，优化技术已经有将近20多年的发展历史，如下图所示：

Web Vitals

Google在2020年推出了一个名为Web Vitals的新概念，着重评估一组页面访问体验钟的一部分关键指标，目的在于简化网络性能。每个指标代表页面体验的一个关键方面：加载、交互和视觉稳定性。

Web Vitals在感知的性能，交互性和令人愉悦的方面，可作为用户体验的简化基准。在考虑页面性能时，应该首先关注这一套较小的指标。

此外，Web Vitals代表了访问者在访问您的页面时首先在其视口中看到的内容，即首屏内容。他们首先看到的内容最终会影响他们对页面性能的看法。

首先，专注于这三个指标，可以使您获得可感知的和实际的性能可观的收益，然后再深入研究其他优化。

加载

所谓加载，就是进入页面时，页面内容的载入过程。比如，当你打开一些网站时，你会发现，有的网站首页上的文字、图片出现很缓慢，而有的则很快，这个内容出现的过程就是加载。加载缓慢严重消耗用户的耐心，会让用户离开页面。

这里我们拿淘宝首页的network信息观察一些指标：

当鼠标悬浮在具体的色块上，我们可以看到具体的指标详情。如下图所示，资源下载之前经历了0.46ms的排队（Queueing），DNS查找24.79ms（DNS Lookup)、建立TCP连接(Initial connection)、还有https的网站SSL证书验证的时间37.04ms（SSL），最后发送请求再到资源返回也要经历110.71ms（TTFB）。

下面我们再来纵向看瀑布图，主要看2点：

1. 资源之间的联系：如果下载发生了阻塞，很多资源的下载就会是串行处理的。如果是并行的，就可以加快下载过程。


2. 关键时间节点：我们可以看到图中有红蓝两个颜色的两根线，蓝色的是DOM完成的加载时间，红色是页面中所有声明的资源加载完成的时间。

关键指标

那么这么多指标，到底哪些是最值得我们关注的呢？下面我来总结一下：

1. 
   

   白屏时间（FP，First Paint）：也叫首次绘制时间，对于应用页面，首次出现视觉上不同于跳转之前内容的时间点，或者说是页面发生第一次绘制的时间点，它的标准时间是 300ms。如果白屏时间过长，用户会认为我们的页面不可用，或者可用性差。如果超过一定时间（如 1s），用户注意力就会转移到其他页面。

   
   


2. 
   

   首屏时间（FCP，First Contentful Paint）：也叫首次有内容绘制时间，对于所有的网页应用，这是一个非常重要的指标。它是指从浏览器输入地址并回车后，到首屏内容渲染完毕的时间。这期间不需要滚动鼠标或者下拉页面，否则无效。也就是说，它是浏览器完成渲染DOM中第一部分内容（可能是文本、图像或其它任何元素）的时间点，此时用户应该在视觉上有直观的感受。

   
   


3. 
   

   首次有意义绘制（FMP，First Meaningful Paint）：指页面关键元素的渲染时间。这个概念并没有标准化定义，因为关键元素可以由开发者自行定义究竟什么是“有意义”的内容，只有开发者或者产品经理自己了解。

   
   


4. 
   

   速度指数（Speed Index）：指的是网页以多快的速度展示内容，标准时间是4s。

   
   


5. 
   

   总下载时间（Load）：页面所有资源加载完成所需要的时间。一般可以统计 window.onload，得到同步加载的资源全部加载完的耗时。如果页面中存在较多异步渲染，那么可以将异步渲染全部完成的时间作为总下载时间。

   
   


6. 
   

   TTFB（Time To First Byte）：是指网络请求被发起到从服务器接收到地一个字节的这段时间。其中包含了TCP连接时间、发送HTTP请求时间和获得相应消息第一个字节的时间。

   
   

   TTFB这个参数比较重要，因为它可以给用户最直观的感受，如果TTFB很慢，说明资源一直没有返回，增加白屏时间，如果TTFB很快，资源回来之后就可以进行快速的解析和渲染。

   
   

   那么影响TTFB的因素有哪些？

   
   
   
   
   1. 后台处理能力，服务器响应到底有多快
   
   
   2. 资源请求的网络状况，网络是否有延迟

首屏时间 vs 白屏时间

首屏时间 = 白屏时间 + 渲染时间。在加载性能指标方面，相比于白屏时间，首屏时间更重要。为什么？

从重要性角度看，打开页面后，第一眼看到的内容一般都非常关键，比如电商的头图、商品价格、购买按钮等。这些内容即便在最恶劣的网络环境下，我们也要确保用户能看得到。

从体验完整性角度看，进入页面后先是白屏，随着第一个字符加载，到首屏内容显示结束，我们才会认为加载完毕，用户可以使用了。白屏加载完成后，仅仅意味着页面内容开始加载，但我们还是没法完成诸如下单购买等实际操作，首屏时间结束后则可以。

DOMContentLoaded和Load事件的区别

其实从这两个事件的命名就能体会到，DOMContentLoaded 指的是文档中 DOM 加载内容加载完毕的时间，也就是说 HTML 结构已经是完整的了。但是我们知道，很多页面都包含图片、特殊字体、视频、音频等其他资源，由于这些资源由网络请求获取，需要额外的网络请求，因此DOM内容如加载完毕时，这些资源还没有请求或渲染完成。当页面上所有资源加载完成后，Load 事件才会被触发。

因此，在时间线上，Load 事件往往会落后于 DOMContentLoaded 事件。

交互/响应

所谓交互，就是用户点击网站或 App 的某个功能，页面给出的回应，也就是浏览器的响应时间。比如我们点击了一个“点赞”按钮，立刻给出了点赞数加一的展示，这就是交互体验好，反之如果很长时间都没回应，这就是交互体验不好。

关于交互指标，有的公司用 FID 指标 （First Input Delay，首次输入延迟）， 指标必须尽量小于 100ms，如果过长会给人页面卡顿的感觉。还有的公司使用 PSI（Perceptual Speed Index，视觉变化率），衡量标准是小于20%。

一般来说，主要包括以下几个指标：

1. 
   

   交互动作的反馈时间：也叫用户可交互时间，就是用户可以与应用进行加护的时间，一般来讲，我们认为是 DOMReady 的时间，因为我们通常会在这时绑定事件操作。如果页面中设计交互的脚本没有下载完成，那么当然没有达到所谓的用户可交互时间。那么如何定义 DOMReady 时间呢？这里我推荐大家看司徒正美的文章《何谓DOMReady》。

   
   


2. 
   

   刷新率（FPS，Frame Per Second）：也叫帧率，标准的刷新率指标是60帧/s，它可以决定画面是否足够流畅。

   
   


3. 
   

   异步请求的完成时间：所有的异步请求能在1s中内请求回来。

   
   

关于帧率，我们可以用chorme Devtools来查看，打开控制台，点击快捷键command/ctrl+shift+P，弹出下面的弹窗，输入frame，点击FPS一栏，就会在页面左上角看到图2所示的监控台，显示网页交互过程中每一帧的绘制频率。

不同帧率的体验

• 帧率能够达到 50 ～ 60 FPS 的动画将会相当流畅，让人倍感舒适；


• 帧率在 30 ～ 50 FPS 之间的动画，因各人敏感程度不同，舒适度因人而异；


• 帧率在 30 FPS 以下的动画，让人感觉到明显的卡顿和不适感；


• 帧率波动很大的动画，亦会使人感觉到卡顿

现在网上很多关于浏览器reflow的文章都说给要少用offsetTop, offsetLeft 等获取布局信息的。因为这些属性需要触发一次浏览器的的Layout。也就是说在一帧内（16ms）会多了一次layout。如果Layout的次数太多，就会导致掉帧。

视觉稳定性

视觉稳定性指标CLS（Cumulative Layout Shift），也就是布局偏移量，它是指页面从一帧切换到另外一帧时，视线中不稳定元素的偏移情况。

比如，你想要购买的商品正在参加抢购活动，而且时间快要到了。在你正要点击页面链接购买的时候，原来的位置插入了一条 9.9 元包邮的商品广告。结果会怎样？你点成了那个广告商品。如果等你再返回购买的时候，你心仪商品的抢购活动结束了，你是不是很气？所以，CLS也非常重要。

一个好的CLS分数是75%以上的用户小于0.1，如图所示：

布局偏移的具体内容

布局偏移是由 Layout Instability API 定义的。这个API会在任意时间上报 layout-shift 的条目，当一个可见元素在两帧之间，改变了它的起始位置（默认的 writing mode 下指的是top和left属性）。这些元素被当成不稳定元素。

需要注意的是，布局偏移只发生在已经存在的元素改变起始位置的时候。如果一个新的元素被添加到dom上，或者已存在的元素改变它的尺寸，除非改变了其他元素的起始位置，否则都不算布局偏移。

布局偏移主要包含以下几项：

1. 
   

   布局偏移分数：布局偏移的分数是两个度量的乘积：影响分数(impact fraction)和距离分数(distance fraction)。如果是一个很大的元素移动了较小的距离，实际影响并不大，所以分数需要依赖两个度量。

   
   


2. 
   

   影响分数：影响分数测试的是两帧之间，不稳定元素在视图上的影响范围。

   
   


3. 
   

   距离分数：距离分数测试的是两帧之间，不稳定元素在视图上移动的距离（水平和纵向取最大值）。如果有多个不稳定元素，也是取其中最大的一个。

   
   


4. 
   

   动画和过渡：动画和过渡，如果做得好，对用户而言是一个不错的更新内容的方式，这样不会给用户“惊喜”。突然出现的或者预料之外的内容，会给用户一个很差的体验。但如果是一个动画或者过渡，用户可以很清楚的知道发生了什么，在状态变化的时候可以很好的引导用户。

   
   

   CSS中的 transform 属性可以让你在使用动画的时候不会产生布局偏移。

   
   
   
   
   • 用 transform:scale() 来替换 width 和 height 属性
   
   
   • 用 transform:translate() 来替换 top, left, bottom, right 属性
   
   
   
   

CLS是平时开发很少关注的点，页面视觉稳定性对很多web开发而言，可能没有加载性能那么关注度高，但对用户而言，这确实是很困扰的一点。平时开发中，尽可能的提醒自己，不管是产品交互图出来之后，或者是UI的视觉稿出来之后，如果出现了布局偏移的情况，都可以提出这方面的意见。开发过程中也尽可能的遵循上面提到的一些优化点，给用户一个稳定的视觉体验。

RAIL测量模型

RAIL模型是2015年google提出的一个可以量化的测量标准，通过RAIL模型可以指导性能优化的目标，让良好的用户体验成为可能。

1. 
   

   Response 响应：是指用户操作网页的时候浏览器给到用户的反馈时间，其中处理事件应在50ms以内完成。

   
   

   为什么是50ms？谷歌向向用户发起调研，将用户的反馈分成了几个组，经过研究得出用户能接受的反馈时间是100ms。

   
   

   那么为什么我们要设置在50ms以内，因为100ms是用户输入到反馈的时间，但是浏览器处理反馈也需要时间，所以留给开发者优化处理事件的时间在50ms以内。如下图所示：

优质的图片可以有效吸引用户，给用户良好的体验，所以随着互联网的发展，越来越多的产品开始使用图片来提升产品体验。相较于页面其他元素，图片的体积不容忽视。下图是截止 2019 年 6 月 HTTP Archive[1] 上统计的网站上各类资源加载的体积：

1.1. 雪碧图

图片可以合并么？当然。最为常用的图片合并场景就是雪碧图（Sprite）^[3]。

在网站上通常会有很多小的图标，不经优化的话，最直接的方式就是将这些小图标保存为一个个独立的图片文件，然后通过 CSS 将对应元素的背景图片设置为对应的图标图片。这么做的一个重要问题在于，页面加载时可能会同时请求非常多的小图标图片，这就会受到浏览器并发 HTTP 请求数的限制。我见过一个没有使用雪碧图的页面，首页加载时需要发送 20+ 请求来加载图标。将图标合并为一张大图可以实现「20+ → 1」的巨大缩减。

雪碧图的核心原理在于设置不同的背景偏移量，大致包含两点：

• 不同的图标元素都会将 background-url 设置为合并后的雪碧图的 uri；


• 不同的图标通过设置对应的 background-position 来展示大图中对应的图标部分。

你可以用 Photoshop 这类工具自己制作雪碧图。当然比较推荐的还是将雪碧图的生成集成到前端自动化构建工具中，例如在 webpack 中使用 webpack-spritesmith，或者在 gulp 中使用 gulp.spritesmith。它们两者都是基于于 spritesmith 这个库，你也可以自己将这个库集成到你喜欢的构建工具中。

1.2. 懒加载

我们知道，一般来说我们访问一个页面，浏览器加载的整个页面其实是要比可视区域大很多的，也是什么我们会提出“首屏”的概念。这就导致其实很多图片是不在首屏中的，如果我们都加载的话，相当于是加载了用户不一定会看到图片。而图片体积一般都不小，这显然是一种流量的浪费。这种场景在一些带图片的长列表或者配图的博客中经常会遇到。

解决的核心思路就是图片懒加载 —— 尽量只加载用户正在浏览或者即将会浏览到的图片。实现上来说最简单的就是通过监听页面滚动，判断图片是否进入视野，从而真正去加载图片：

function loadIfNeeded($img) {
    const bounding = $img..getBoundingClientRect();
    if (
        getComputedStyle($img).display !== 'none'
        && bounding.top <= window.innerHeight
        && bounding.bottom >= 0
    ) {
        $img.src = $img.dataset.src;
        $img.classList.remove('lazy');
    }
}

// 这里使用了 throttle，你可以实现自己的 throttle，也可以使用 lodash
const lazy = throttle(function () {
    const $imgList = document.querySelectorAll('.lazy');
    if ($imgList.length === 0) {
        document.removeEventListener('scroll', lazy);
        window.removeEventListener('resize', lazy);
        window.removeEventListener('orientationchange', lazy);
        return;
    }
    $imgList.forEach(loadIfNeeded);
}, 200);

document.addEventListener('scroll', lazy);
window.addEventListener('resize', lazy);
window.addEventListener('orientationchange', lazy);

对于页面上的元素只需要将原本的 src 值设置到 data-src 中即可，而 src 可以设置为一个统一的占位图。注意，由于页面滚动、缩放和横竖方向（移动端）都可能会改变可视区域，因此添加了三个监听。

当然，这是最传统的方法，现代浏览器还提供了一个更先进的 Intersection Observer API^[4] 来做这个事，它可以通过更高效的方式来监听元素是否进入视口。考虑兼容性问题，在生产环境中建议使用对应的 polyfill。

如果想使用懒加载，还可以借助一些已有的工具库，例如 aFarkas/lazysizes、verlok/lazyload、tuupola/lazyload 等。

在使用懒加载时也有一些注意点：

• 首屏可以不需要懒加载，对首屏图片也使用懒加载会延迟图片的展示。


• 设置合理的占位图，避免图片加载后的页面“抖动”。


• 虽然目前基本所有用户都不会禁用 JavaScript，但还是建议做一些 JavaScript 不可用时的 backup。

对于占位图这块可以再补充一点。为了更好的用户体验，我们可以使用一个基于原图生成的体积小、清晰度低的图片作为占位图。这样一来不会增加太大的体积，二来会有很好的用户体验。LQIP (Low Quality Image Placeholders)^[5] 就是这种技术。目前也已经有了 LQIP 和 SQIP(SVG-based LQIP) 的自动化工具可以直接使用。

如果你想了解更多关于图片懒加载的内容，这里有一篇更详尽的图片懒加载指南^[6]。

1.3. CSS 中的图片懒加载

除了对于 <img> 元素的图片进行来加载，在 CSS 中使用的图片一样可以懒加载，最常见的场景就是 background-url 

.login {
    background-url: url(/static/img/login.png);
}

对于上面这个样式规则，如果不应用到具体的元素，浏览器不会去下载该图片。所以你可以通过切换 className 的方式，放心得进行 CSS 中图片的懒加载。

1.4. 内联 base64

还有一种方式是将图片转为 base64 字符串，并将其内联到页面中返回，即将原 url 的值替换为 base64。这样，当浏览器解析到这个的图片 url 时，就不会去请求并下载图片，直接解析 base64 字符串即可。

但是这种方式的一个缺点在于相同的图片，相比使用二进制，变成 base64 后体积会增大 33%。而全部内联进页面后，也意味着原本可能并行加载的图片信息，都会被放在页面请求中（像当于是串行了）。同时这种方式也不利于复用独立的文件缓存。所以，使用 base64 需要权衡，常用于首屏加载 CRP 或者骨架图上的一些小图标。

2. 减小图片大小

2.1. 使用合适的图片格式

使用合适的图片格式不仅能帮助你减少不必要的请求流量，同时还可能提供更好的图片体验。

图片格式是一个比较大的话题，选择合适的格式^[7]有利于性能优化。这里我们简单总结一些。

1) 使用 WebP：

考虑在网站上使用 WebP 格式^[8]。在有损与无损压缩上，它的表现都会优于传统（JPEG/PNG）格式。WebP 无损压缩比 PNG 的体积小 26%，webP 的有损压缩比同质量的 JPEG 格式体积小 25-34%。同时 WebP 也支持透明度。下面提供了一种兼容性较好的写法。

<picture>
    <source type="image/webp" srcset="/static/img/perf.webp">
    <source type="image/jpeg" srcset="/static/img/perf.jpg">
    <img src="/static/img/perf.jpg">
</picture>

2) 使用 SVG 应对矢量图场景：

在一些需要缩放与高保真的情况，或者用作图标的场景下，使用 SVG 这种矢量图非常不错。有时使用 SVG 格式会比相同的 PNG 或 JPEG 更小。

3) 使用 video 替代 GIF：

在兼容性允许的情况下考虑，可以在想要动图效果时使用视频，通过静音（muted）的 video 来代替 GIF。相同的效果下，GIF 比视频（MPEG-4）大 5～20 倍。Smashing Magazine 上有篇文章^[9]详细介绍使用方式。

4) 渐进式 JPEG：

基线 JPEG (baseline JPEG) 会从上往下逐步呈现，类似下面这种：

而另一种渐进式 JPEG (progressive JPEG)[10] 则会从模糊到逐渐清晰，使人的感受上会更加平滑。

<img srcset="small.jpg 480w, large.jpg 1080w" sizes="50w" src="large.jpg" >

用户喜欢快速的网络应用，他们希望页面加载速度快，功能流畅。如果在滚动时有破损的动画或滞后，用户很有可能会离开你的网站。作为一名开发者，你可以做很多事情来改善用户体验。本文将重点介绍4个可以用来提高页面渲染速度的CSS技巧。

1. Content-visibility

一般来说，大多数Web应用都有复杂的UI元素，它的扩展范围超出了用户在浏览器视图中看到的内容。在这种情况下，我们可以使用内容可见性（ content-visibility ）来跳过屏幕外内容的渲染。如果你有大量的离屏内容，这将大大减少页面渲染时间。

这个功能是最新增加的功能之一，也是对提高渲染性能影响最大的功能之一。虽然 content-visibility 接受几个值，但我们可以在元素上使用 content-visibility: auto; 来获得直接的性能提升。

让我们考虑一下下面的页面，其中包含许多不同信息的卡片。虽然大约有12张卡适合屏幕，但列表中大约有375张卡。正如你所看到的，浏览器用了1037ms来渲染这个页面。

下一步，您可以向所有卡添加 content-visibility 。

在这个例子中，在页面中加入 content-visibility 后，渲染时间下降到150ms，这是6倍以上的性能提升。

正如你所看到的，内容可见性是相当强大的，对提高页面渲染时间非常有用。根据我们目前所讨论的东西，你一定是把它当成了页面渲染的银弹。

然而，有几个领域的内容可视性不佳。我想强调两点，供大家参考。

• 此功能仍处于试验阶段。 截至目前，Firefox（PC和Android版本）、IE（我认为他们没有计划在IE中添加这个功能）和，Safari（Mac和iOS）不支持内容可见性。


• 与滚动条行为有关的问题。 由于元素的初始渲染高度为0px，每当你向下滚动时，这些元素就会进入屏幕。实际内容会被渲染，元素的高度也会相应更新。这将使滚动条的行为以一种非预期的方式进行。

为了解决滚动条的问题，你可以使用另一个叫做 contain-intrinsic-size 的 CSS 属性。它指定了一个元素的自然大小，因此，元素将以给定的高度而不是0px呈现。

.element{
  content-visibility: auto;
  contain-intrinsic-size: 200px;
}

浏览器上的动画并不是一件新鲜事。通常情况下，这些动画是和其他元素一起定期渲染的。不过，现在浏览器可以使用GPU来优化其中的一些动画操作。

通过will-change CSS属性，我们可以表明元素将修改特定的属性，让浏览器事先进行必要的优化。

下面发生的事情是，浏览器将为该元素创建一个单独的层。之后，它将该元素的渲染与其他优化一起委托给GPU。这将使动画更加流畅，因为GPU加速接管了动画的渲染。

// In stylesheet
.animating-element {
  will-change: opacity;
}

// In HTML
<div class="animating-elememt">
  Animating Child elements
</div>

当在浏览器中渲染上述片段时，它将识别 will-change 属性并优化未来与不透明度相关的变化。

根据Maximillian Laumeister所做的性能基准，可以看到他通过这个单行的改变获得了超过120FPS的渲染速度，而最初的渲染速度大概在50FPS。

.my-class{
  will-change: opacity;
}
.child-class{
  transition: opacity 1s ease-in-out;
}

<link rel="stylesheet" href="styles.css">

<!-- style.css contains only the minimal styles needed for the page rendering -->
<link rel="stylesheet" href="styles.css" media="all" />
<!-- Following stylesheets have only the styles necessary for the form factor -->
<link rel="stylesheet" href="sm.css" media="(min-width: 20em)" />
<link rel="stylesheet" href="md.css" media="(min-width: 64em)" />
<link rel="stylesheet" href="lg.css" media="(min-width: 90em)" />
<link rel="stylesheet" href="ex.css" media="(min-width: 120em)" />
<link rel="stylesheet" href="print.css" media="print" />

# style.css
@import url("windows.css");
# windows.css
@import url("componenets.css");

总结

情景再现

很多时候,当我们写程序都会有这样的情况,就是代码多选操作.例如下面的操作.

比如有四个视图View(分别为A,B,C,D);
当点击按钮a的时候,视图A,B背景色发生改变;
当点击按钮b的时候,视图A,B,D背景色发生改变;
当点击按钮c的时候,视图B,C,D背景色发生改变;
后续开发中可能有很多按钮和不同的组合形式.

这时候你会怎么办?

第一种方案: 所有的按钮就响应一个方法,里面使用if else等模块来区分不同的按钮事件.
思考问题: 后期如果增加一种按钮.你就需要增加一个if else,代码增加的同时,if else逻辑层级太多也不利于阅读.

第二种方案: if else性能太低?我们就使用Switch.配合着枚举值或者按钮的Tag值来做区别判断,枚举值可以定义成每一种组合形式都是一个枚举值.不同按钮相同的组合形式进入同样的模块.
思考问题: 虽然Switch使用break关键词相对于普通的if else有很大的性能提高,但是后期如果增加一种情况,仍然需要添加代码块.还是会增加代码量.

这时候我们总结一下上面倒是需要干什么,以及出现的问题.

需求: 组合是具有不确定性的,但是组合中的基本元素是确定的(A,B,C,D中的任意组合).

问题: 普通的方式不管if else或者Switch都可能会需要罗列出所有的组合形式,代码量很大,不符合代码规范.阅读起来也是相当的困难.

难道就没有更加优雅的方式来解决这个问题吗?这当然是有的,那就是我们的今天猪脚 位运算符.使用位运算符可以很好的帮助我们解决这一问题.但是在此之前我们需要先了解什么叫做位移运算符.

位运算符

按位与和按位或举个例子来看下.

按位与

1001
 &
 0101
=0001

按位或

1001
 &
 0101
=1101

按位异或

1001
 ^
 0101
=1100

我们了解了位运算符,我们该如何解决最开始的那种问题呢?我们接着看~

解决问题

→ Demo传送门,对照着看

解决这种问题我们会用到 << 和& 以及 | 这三种位运算符.

首先定义一个ColorView视图,继承于UIView,然后在 .h 头文件定义枚举,并且ColorView持有枚举的属性.代码如下所示.

#import <UIKit/UIKit.h>

typedef enum : NSUInteger {
    ColorViewStyleA     = 1<<0,
    ColorViewStyleB     = 1<<1,
    ColorViewStyleC     = 1<<2,
    ColorViewStyleD     = 1<<3,
} ColorViewStyle;

@interface ColorView : UIView

@property(nonatomic,assign)ColorViewStyle style;
@property(nonatomic,copy)NSString *title;

@end

然后在ViewController导入ColorView,并且声明一个属性needChangeColorStyle.用于判断需要做出修改的视图.

#import "ColorView.h"
@interface ViewController ()

@property(nonatomic,assign)ColorViewStyle needChangeColorStyle;

@end

然后在ViewController创建ColorView和Button,这里由于时间原因,我就简写了.主要要给每种视图设置一个枚举值,作为识别码.

//创建ColorView
    for (int i = 0; i < 4; i++) {
        
        ColorView *colorView = [[ColorView alloc] initWithFrame:CGRectMake(viewWidth * i + distance *(i+1), 100, viewWidth, 100)];

        ............

        switch (i) {
            case 0:
                colorView.style = ColorViewStyleA;
                break;
            case 1:
                colorView.style = ColorViewStyleB;
                break;
            case 2:
                colorView.style = ColorViewStyleC;
                break;
            case 3:
                colorView.style = ColorViewStyleD;
                break;
        }
       ............
    }

    //创建按钮
    for (int i = 0; i < 4; i++) {
       ............
    }

然后在按钮的点击方法 buttonAction 里面重置needChangeColorStyle的值,这里就需要使用到按位或进行枚举值的组合了.如下所示.

- (void)buttonAction:(UIButton *)sender {
    
    //对 needChangeColorStyle 进行赋值,其实这步操作应该在一开始做的,这里是Demo,所以这么做了.
    //赋值过程中使用了按位或运算符.整合可响应的View类型.
    NSInteger tagIndex = sender.tag - 10000;
    switch (tagIndex) {
        case 0:
            _needChangeColorStyle = ColorViewStyleA|ColorViewStyleB|ColorViewStyleD;
            break;
        case 1:
            _needChangeColorStyle = ColorViewStyleB|ColorViewStyleC|ColorViewStyleD;
            break;
        case 2:
            _needChangeColorStyle = ColorViewStyleA|ColorViewStyleB;
            break;
        case 3:
            _needChangeColorStyle = ColorViewStyleD;
            break;
    }
    [self colorViewsChangAction];
}

最后在colorViewsChangAction方法中进行视图的操作选择.使用到了按位与运算.只要视图的style和_needChangeColorStyle有相交部分,那么两者按位与出来的数值一定是大于等于1的.这样就可以做包含操作了.代码日下所示.

- (void)colorViewsChangAction {
    
    //遍历ColorView视图数组
    for (ColorView *colorView in self.colorViews) {
        //使用了按位与,查看两者是否具有相交部分.
        if (_needChangeColorStyle & colorView.style) {
            NSLog(@"%@ 做出了响应",colorView.title);
            colorView.backgroundColor = [UIColor redColor];
        } else {
            colorView.backgroundColor = [UIColor orangeColor];
        }
    }
}

这样我们就完成了使用位运算做任何组合判断的操作了,后期我们加一种按钮或者组合形式,只需要在 buttonAction 添加三行代码即可.其他都不用了,而且代码结构读起来非常的舒服.

当然了,在iOS原生框架也是有这样的操作的,例如对于贝塞尔曲线的指定角进行切边操作.枚举值也是带有位移运算的,枚举值如下所示.这时候可以仍然可以使用按位或组合任意形式的角.

typedef NS_OPTIONS(NSUInteger, UIRectCorner) {
    UIRectCornerTopLeft     = 1 << 0,
    UIRectCornerTopRight    = 1 << 1,
    UIRectCornerBottomLeft  = 1 << 2,
    UIRectCornerBottomRight = 1 << 3,
    UIRectCornerAllCorners  = ~0UL
};

总结

位运算符还有很多用途,这是最简单的用途而已,在安卓那边的话,如果枚举有性能问题,可以使用定义常量的形式来实现该目的,整体上是一致的,好了就说到这里,如果有任何问题,欢迎批评指导,谢谢.最后再把Demo发一遍.

转自：https://www.jianshu.com/p/5ed73f85ac37

前言

之前写过一个 日志框架LogHelper ,是基于 Logger 开源库封装的，当时的因为项目本身的日志不是很多，完全可以使用，最近和其他公司合作，在一个新的项目上反馈，说在 大量log 的情况下会影响到手机主体功能的使用。从而让我对之前的日志行为做了一个深刻的反省随后在开发群中咨询了其他开发的小伙伴，如果追求性能，可以研究一下 微信的 xlog ,也是本篇博客的重点

xlog 是什么

xlog 是什么 这个问题 我这也是在【腾讯Bugly干货分享】微信mars 的高性能日志模块 xlog得到了答案
简单来说 ，就是腾讯团队分享的基于 c/c++ 高可靠性高性能的运行期日志组件

官网的 sample

知道了他是什么，就要只要他是怎么用的，打开github 找到官网Tencent/mars
使用非常简单

下载库

dependencies {
    compile 'com.tencent.mars:mars-xlog:1.2.3'
}

使用

System.loadLibrary("c++_shared");
System.loadLibrary("marsxlog");

final String SDCARD = Environment.getExternalStorageDirectory().getAbsolutePath();
final String logPath = SDCARD + "/marssample/log";

// this is necessary, or may crash for SIGBUS
final String cachePath = this.getFilesDir() + "/xlog"

//init xlog
if (BuildConfig.DEBUG) {
    Xlog.appenderOpen(Xlog.LEVEL_DEBUG, Xlog.AppenderModeAsync, cachePath, logPath, "MarsSample", 0, "");
    Xlog.setConsoleLogOpen(true);

} else {
    Xlog.appenderOpen(Xlog.LEVEL_INFO, Xlog.AppenderModeAsync, cachePath, logPath, "MarsSample", 0, "");
    Xlog.setConsoleLogOpen(false);
}

Log.setLogImp(new Xlog());

OK 实现了他的功能

不要高兴的太早，后续的问题都头大

分析各个方法的作用

知道了最简单的用法，就想看看他支持哪些功能

按照官网的demo 首先分析一下appenderOpen

appenderOpen(int level, int mode, String cacheDir, String logDir, String nameprefix, int cacheDays, String pubkey)

level

日志级别 没啥好说的 XLog 中已经写得很清楚了

public static final int LEVEL_ALL = 0;
public static final int LEVEL_VERBOSE = 0;
public static final int LEVEL_DEBUG = 1;
public static final int LEVEL_INFO = 2;
public static final int LEVEL_WARNING = 3;
public static final int LEVEL_ERROR = 4;
public static final int LEVEL_FATAL = 5;
public static final int LEVEL_NONE = 6;

值得注意的地方 debug 版本下建议把控制台日志打开，日志级别设为 Verbose 或者 Debug, release 版本建议把控制台日志关闭，日志级别使用 Info.

public static native void setLogLevel(int logLevel);

这个在官网的 接入指南

这里也可以使用

方法设置

mode

写入的模式

• public static final int AppednerModeAsync = 0;

异步写入

• public static final int AppednerModeSync = 1;

同步写入

同步写入，可以理解为实时的日志，异步则不是

Release版本一定要用 AppednerModeAsync， Debug 版本两个都可以，但是使用 AppednerModeSync 可能会有卡顿

这里也可以使用

public static native void setAppenderMode(int mode);

方法设置

cacheDir 设置缓存目录

缓存目录，当 logDir 不可写时候会写进这个目录，可选项，不选用请给 ""， 如若要给，建议给应用的 /data/data/packname/files/log 目录。

会在目录下生成后缀为 .mmap3 的缓存文件，

logDir 设置写入的文件目录

真正的日志，后缀为 .xlog

日志写入目录，请给单独的目录，除了日志文件不要把其他文件放入该目录，不然可能会被日志的自动清理功能清理掉。

nameprefix 设置日志文件名的前缀

日志文件名的前缀，例如该值为TEST，生成的文件名为：TEST_20170102.xlog。

cacheDays

一般情况下填0即可。非0表示会在 _cachedir 目录下存放几天的日志。

这里的描述比较晦涩难懂，当我设置这个参数非0 的时候 会发现 原本设置在 logDir 目录下的文件 出现在了 cacheDir

例如 正常应该是

文件结构

- cacheDir
   - log.mmap3
- logDir
   - log_20200710.xlog
   - log_20200711.xlog

变成这样

- cacheDir
   - log.mmap3
   - log_20200710.xlog
   - log_20200711.xlog
- logDir

全部到了 cacheDir 下面

cacheDays 的意思是 在多少天以后 从缓存目录移到日志目录

pubkey 设置加密的 pubkey

这里涉及到了日志的加密与解密，下面会专门介绍

setMaxFileSize 设置文件大小

在 Xlog 下有一个 native 方法

	public static native void setMaxFileSize(long size);

他表示 最大文件大小，这里需要说一下，原本的默认设置 是一天一个日志文件在 appender.h 描述的很清楚

/*
 * By default, all logs will write to one file everyday. You can split logs to multi-file by changing max_file_size.
 *
 * @param _max_byte_size    Max byte size of single log file, default is 0, meaning do not split.
 */
void appender_set_max_file_size(uint64_t _max_byte_size);

默认情况下，所有日志每天都写入一个文件。可以通过更改max_file_size将日志分割为多个文件。单个日志文件的最大字节大小，默认为0，表示不分割

当超过设置的文件大小以后。文件会变成如下目录结构

- cacheDir
   - log.mmap3
- logDir
   - log_20200710.xlog
   - log_20200710_1.xlog
   - log_20200710_2.xlog

在 appender.cc 对应的有如下逻辑，

static long __get_next_fileindex(const std::string& _fileprefix, const std::string& _fileext) {
    ...
    return (filesize > sg_max_file_size) ? index + 1 : index;

setConsoleLogOpen 设置是否在控制台答应日志

···java public static native void setConsoleLogOpen(boolean isOpen); ···

设置是否在控制台答应日志

setErrLogOpen

这个方法是没用的，一开始以为哪里继承的有问题，在查看源码的时候发现 他是一个空方法，没有应用

使用的话会导致程序异常,在自己编译的so 中我就把它给去掉了

setMaxAliveTime 设置单个文件最大保留时间

public static native void setMaxAliveTime(long duration);

置单个文件最大保留时间 单位是秒，这个方法有3个需要注意的地方，

• 必须在 appenderOpen 方法之前才有效
• 最小的时间是 一天
• 默认的时间是10天

在 appender.cc 中可以看到

static const long kMaxLogAliveTime = 10 * 24 * 60 * 60;    // 10 days in second
static const long kMinLogAliveTime = 24 * 60 * 60;    // 1 days in second
static long sg_max_alive_time = kMaxLogAliveTime;
....
void appender_set_max_alive_duration(long _max_time) {
	if (_max_time >= kMinLogAliveTime) {
		sg_max_alive_time = _max_time;
	}
}

默认的时间是10天

appenderClose

在 文档中介绍说是在 程序退出时关闭日志 调用appenderClose的方法

然而在实际情况中 Application 类的 onTerminate() 只有在模拟器中才会生效，在真机中无效的，

如果在程序退出的时候没有触发 appenderClose 那么在下一次启动的时候，xlog 也会把日志写入到文件中

所以如何触发呢？

建议尽可能的去触发他 例如用户双击back 退出的情况下 你肯定是知道的 如果放在后台被杀死了，这个时候也真的没办法刷新，也没关系，上面也说了，再次启动的时候会刷新到日志中，

appenderFlush

当日志写入模式为异步时，调用该接口会把内存中的日志写入到文件。

isSync : true 为同步 flush，flush 结束后才会返回。 isSync : false 为异步 flush，不等待 flush 结束就返回。

日志文件的加密

这一块单独拿出来说明，是因为之前使用上遇到了坑

首先是这个 入参 PUB_KEY,一脸懵，是个啥，

在 mars/blob/master/mars/log/crypt/gen_key.py 这个就是能够获取到 PUB_KEY 的方法

运行如下

$ python gen_key.py

WARNING: Executing a script that is loading libcrypto in an unsafe way. This will fail in a future version of macOS. Set the LIBRESSL_REDIRECT_STUB_ABORT=1 in the environment to force this into an error.

save private key

471e607b1bb3760205f74a5e53d2764f795601e241ebc780c849e7fde1b4ce40



appender_open's parameter:

300330b09d9e771d6163bc53a4e23b188ac9b2f5c7150366835bce3a12b0c8d9c5ecb0b15274f12b2dffae7f4b11c3b3d340e0521e8690578f51813c93190e1e

上面的 private key 自己保存好

appender_open's parameter: 就是需要的 PUB_KEY

日志文件的解密

上面已经知道如何加密了，现在了解一下如何解密

下载pyelliptic1

在Xlog 加密使用指引中能够看到

需要下载 pyelliptic1.5.7 然后编译 否则下面的命令会失败

直接解密脚本

xlog 很贴心的给我们提供了两个脚本

使用 decode_mars_nocrypt_log_file.py 解压没有加密的

python decode_mars_nocrypt_log_file [path]

使用 decode_mars_crypt_log_file.py 加密的文件

在使用之前需要将 脚本中的

PRIV_KEY = "145aa7717bf9745b91e9569b80bbf1eedaa6cc6cd0e26317d810e35710f44cf8"

PUB_KEY = "572d1e2710ae5fbca54c76a382fdd44050b3a675cb2bf39feebe85ef63d947aff0fa4943f1112e8b6af34bebebbaefa1a0aae055d9259b89a1858f7cc9af9df1"

改成上面自己获取到的 key 否则是解压不出来的

python decode_mars_crypt_log_file.py ~/Desktop/log/log_20200710.xlog

直接生成一个

- cacheDir

    - log.mmap3

- logDir

    - log_20200710.xlog

    - log_20200710.xlog.log

也可以自定义名字

python decode_mars_crypt_log_file.py ~/Desktop/log/log_20200710.xlog ~/Desktop/log/1.log

- cacheDir

    - log.mmap3

- logDir

    - log_20200710.xlog

    - 1.log

修改日志的格式

打开我们解压好的日志查看

^^^^^^^^^^Oct 14 2019^^^20:27:59^^^^^^^^^^[17223,17223][2020-07-24 +0800 09:49:19]
get mmap time: 3
MARS_URL:
MARS_PATH: master
MARS_REVISION: 85b19f92
MARS_BUILD_TIME: 2019-10-14 20:27:57
MARS_BUILD_JOB:
log appender mode:0, use mmap:1
cache dir space info, capacity:57926635520 free:52452691968 available:52452691968
log dir space info, capacity:57926635520 free:52452691968 available:52452691968
[I][2020-07-24 +8.0 09:49:21.179][17223, 17223][TAG][, , 0][======================> 1
[I][2020-07-24 +8.0 09:49:21.180][17223, 17223][TAG][, , 0][======================> 2
[I][2020-07-24 +8.0 09:49:21.180][17223, 17223][TAG][, , 0][======================> 3
[I][2020-07-24 +8.0 09:49:21.180][17223, 17223][TAG][, , 0][======================> 4
[I][2020-07-24 +8.0 09:49:21.181][17223, 17223][TAG][, , 0][======================> 5
[I][2020-07-24 +8.0 09:49:21.181][17223, 17223][TAG][, , 0][======================> 6
[I][2020-07-24 +8.0 09:49:21.182][17223, 17223][TAG][, , 0][======================> 7
[I][2020-07-24 +8.0 09:49:21.182][17223, 17223][TAG][, , 0][======================> 8
[I][2020-07-24 +8.0 09:49:21.182][17223, 17223][TAG][, , 0][======================> 9
[I][2020-07-24 +8.0 09:49:21.183][17223, 17223][TAG][, , 0][======================> 10
[I][2020-07-24 +8.0 09:49:21.183][17223, 17223][TAG][, , 0][======================> 11
[I][2020-07-24 +8.0 09:49:21.183][17223, 17223][TAG][, , 0][======================> 12
[I][2020-07-24 +8.0 09:49:21.184][17223, 17223][TAG][, , 0][======================> 13
[I][2020-07-24 +8.0 09:49:21.184][17223, 17223][TAG][, , 0][======================> 14
[I][2020-07-24 +8.0 09:49:21.185][17223, 17223][TAG][, , 0][======================> 15
[I][2020-07-24 +8.0 09:49:21.185][17223, 17223][TAG][, , 0][======================> 16
[I][2020-07-24 +8.0 09:49:21.185][17223, 17223][TAG][, , 0][======================> 17

我擦泪 除了我们需要的信息以外，还有这么多杂七杂八的信息，如何去掉，并且自己定义一下格式

这里就需要自己去编译 so 了，好在 xlog 已经给我们提供了很好的编译代码

对应的文档 本地编译

对于编译这块按照文档来就好了 需要注意的是

• 一定要用 ndk-r20 不要用最新版本的 21
• 一定用 Python2.7 mac 自带 不用要 Python3

去掉头文件

首先我们去到这个头文件，对于一个日志框架来着，这个没啥用

^^^^^^^^^^Oct 14 2019^^^20:27:59^^^^^^^^^^[17223,17223][2020-07-24 +0800 09:49:19]

get mmap time: 3

MARS_URL:

MARS_PATH: master

MARS_REVISION: 85b19f92

MARS_BUILD_TIME: 2019-10-14 20:27:57

MARS_BUILD_JOB:

log appender mode:0, use mmap:1

cache dir space info, capacity:57926635520 free:52452691968 available:52452691968

log dir space info, capacity:57926635520 free:52452691968 available:52452691968

在本机下载好的 mars 下，找到 appender.cc 将头文件去掉

修改日志格式

默认的格式很长

[I][2020-07-24 +8.0 09:49:21.179][17223, 17223][TAG][, , 0][======================> 1

[日志级别][时间][pid,tid][tag][filename,strFuncName,line][日志内容

是一个这样结构

比较乱，我们想要的日志 就时间，级别，日志内容 就行了

找到 formater.cc

将原本的

int ret = snprintf((char*)_log.PosPtr(), 1024, "[%s][%s][%" PRIdMAX ", %" PRIdMAX "%s][%s][%s, %s, %d][",  // **CPPLINT SKIP**
                           _logbody ? levelStrings[_info->level] : levelStrings[kLevelFatal], temp_time,
                           _info->pid, _info->tid, _info->tid == _info->maintid ? "*" : "", _info->tag ? _info->tag : "",
                           filename, strFuncName, _info->line);

改成

int ret = snprintf((char*)_log.PosPtr(), 1024,     "[%s][%s]",  // **CPPLINT SKIP**
                        temp_time,   _logbody ? levelStrings[_info->level] : levelStrings[kLevelFatal] );

就行了

然后从新编译，将so 翻入项目 在看一下现在的效果

[2020-07-24 +8.0 11:47:42.597][I]======================>9

ok 打完收工

简单的封装一下

基本上分析和实现了我们需要的功能，那么把这部分简单的封装一下

放上核心的 Builder 源码可在下面自行查看

package com.allens.xlog

import android.content.Context
import com.tencent.mars.xlog.Log
import com.tencent.mars.xlog.Xlog

class Builder(context: Context) {

    companion object {
        //日志的tag
        var tag = "log_tag"
    }

    //是否是debug 模式
    private var debug = true


    //是否打印控制台日志
    private var consoleLogOpen = true


    //是否每天一个日志文件
    private var oneFileEveryday = true

    //默认的位置
    private val defCachePath = context.getExternalFilesDir(null)?.path + "/mmap"

    // mmap 位置 默认缓存的位置
    private var cachePath = defCachePath

    //实际保存的log 位置
    private var logPath = context.getExternalFilesDir(null)?.path + "/logDir"

    //文件名称前缀 例如该值为TEST，生成的文件名为：TEST_20170102.xlog
    private var namePreFix = "log"

    //写入文件的模式
    private var model = LogModel.Async

    //最大文件大小
    //默认情况下，所有日志每天都写入一个文件。可以通过更改max_file_size将日志分割为多个文件。
    //单个日志文件的最大字节大小，默认为0，表示不分割
    // 最大 当文件不能超过 10M
    private var maxFileSize = 0L

    //日志级别
    //debug 版本下建议把控制台日志打开，日志级别设为 Verbose 或者 Debug, release 版本建议把控制台日志关闭，日志级别使用 Info.
    private var logLevel = LogLevel.LEVEL_INFO

    //通过 python gen_key.py 获取到的公钥
    private var pubKey = ""

    //单个文件最大保留时间 最小 1天 默认时间 10天
    private var maxAliveTime = 10

    //缓存的天数  一般情况下填0即可。非0表示会在 _cachedir 目录下存放几天的日志。
    //原来缓存日期的意思是几天后从缓存目录移到日志目录
    private var cacheDays = 0

    fun setCachePath(cachePath: String): Builder {
        this.cachePath = cachePath
        return this
    }

    fun setLogPath(logPath: String): Builder {
        this.logPath = logPath
        return this
    }


    fun setNamePreFix(namePreFix: String): Builder {
        this.namePreFix = namePreFix
        return this
    }

    fun setModel(model: LogModel): Builder {
        this.model = model
        return this
    }

    fun setPubKey(key: String): Builder {
        this.pubKey = key
        return this
    }

    //原来缓存日期的意思是几天后从缓存目录移到日志目录 默认 0 即可
    //如果想让文件保留多少天 用 [setMaxAliveTime] 方法即可
    //大于 0  的时候 默认会放在缓存的位置上 [cachePath]
    fun setCacheDays(days: Int): Builder {
        if (days < 0) {
            this.cacheDays = 0
        } else {
            this.cacheDays = days
        }
        return this
    }

    fun setDebug(debug: Boolean): Builder {
        this.debug = debug
        return this
    }

    fun setLogLevel(level: LogLevel): Builder {
        this.logLevel = level
        return this
    }

    fun setConsoleLogOpen(consoleLogOpen: Boolean): Builder {
        this.consoleLogOpen = consoleLogOpen
        return this
    }


    fun setTag(logTag: String): Builder {
        tag = logTag
        return this
    }


    /**
     * [isOpen]  true   设置每天一个日志文件
     *           false  那么  [setMaxFileSize] 生效
     */
    fun setOneFileEveryday(isOpen: Boolean): Builder {
        this.oneFileEveryday = isOpen
        return this
    }

    fun setMaxFileSize(maxFileSize: Float): Builder {
        when {
            maxFileSize < 0 -> {
                this.maxFileSize = 0L
            }
            maxFileSize > 10 -> {
                this.maxFileSize = (10 * 1024 * 1024).toLong()
            }
            else -> {
                this.maxFileSize = (maxFileSize * 1024 * 1024).toLong()
            }
        }
        return this
    }

    /**
     * [day] 设置单个文件的过期时间 默认10天 在程序启动30S 以后会检查过期文件
     *       过期时间依据 当前系统时间 - 文件最后修改时间计算
     *       默认 单个文件保存 10天
     */
    fun setMaxAliveTime(day: Int): Builder {
        when {
            day < 0 -> {
                this.maxAliveTime = 0
            }
            day > 10 -> {
                this.maxAliveTime = 10
            }
            else -> {
                this.maxAliveTime = day
            }
        }
        return this
    }

    fun init() {

        if (!debug) {
            //判断如果是release 就强制使用 异步
            model = LogModel.Async
            //日志级别使用 Info
            logLevel = LogLevel.LEVEL_INFO
        }

        if (cachePath.isEmpty()) {
            //cachePath这个参数必传，而且要data下的私有文件目录，例如 /data/data/packagename/files/xlog， mmap文件会放在这个目录，如果传空串，可能会发生 SIGBUS 的crash。
            cachePath = defCachePath
        }


        android.util.Log.i(tag, "Xlog=========================================>")
        android.util.Log.i(
            tag,
            "info" + "\n"
                    + "level:" + logLevel.level + "\n"
                    + "model:" + model.model + "\n"
                    + "cachePath:" + cachePath + "\n"
                    + "logPath:" + logPath + "\n"
                    + "namePreFix:" + namePreFix + "\n"
                    + "cacheDays:" + cacheDays + "\n"
                    + "pubKey:" + pubKey + "\n"
                    + "consoleLogOpen:" + consoleLogOpen + "\n"
                    + "maxFileSize:" + maxFileSize + "\n"
        )

        android.util.Log.i(tag, "Xlog=========================================<")
        Xlog.setConsoleLogOpen(consoleLogOpen)
        //每天一个日志文件
        if (oneFileEveryday) {
            Xlog.setMaxFileSize(0)
        } else {
            Xlog.setMaxFileSize(maxFileSize)
        }

        Xlog.setMaxAliveTime((maxAliveTime * 24 * 60 * 60).toLong())

        Xlog.appenderOpen(
            logLevel.level,
            model.model,
            cachePath,
            logPath,
            namePreFix,
            cacheDays,
            pubKey
        )
        Log.setLogImp(Xlog())
    }


}

下载

Step 1. Add the JitPack repository to your build file Add it in your root build.gradle at the end of repositories:

allprojects {

		repositories {

			...

			maven { url 'https://www.jitpack.io' }

		}

	}

Step 2. Add the dependency

	dependencies {

	        implementation 'com.github.JiangHaiYang01:XLogHelper:Tag'

	}

添加 abiFilter

android {

    compileSdkVersion 30

    buildToolsVersion "30.0.1"



    defaultConfig {

        ...

        ndk {

            abiFilter "armeabi-v7a"

        }

    }



    ...

}

使用

初始化，建议放在 Application 中

XLogHelper.create(this)
            .setModel(LogModel.Async)
            .setTag("TAG")
            .setConsoleLogOpen(true)
            .setLogLevel(LogLevel.LEVEL_INFO)
            .setNamePreFix("log")
            .setPubKey("572d1e2710ae5fbca54c76a382fdd44050b3a675cb2bf39feebe85ef63d947aff0fa4943f1112e8b6af34bebebbaefa1a0aae055d9259b89a1858f7cc9af9df1")
            .setMaxFileSize(1f)
            .setOneFileEveryday(true)
            .setCacheDays(0)
            .setMaxAliveTime(2)
            .init()

XLogHelper.i("======================> %s", i)
XLogHelper.e("======================> %s", i)

代码下载:

原理

1、将同一个资源，创建出两种模式的样式。系统根据当前选择的样式，自动获取该样式的资源

2、每次系统更新样式时，应用会调用当前所有存在的元素调用对应的一些重新方法，进行重绘视图，可以在对应的方法做相应的改动

资源文件适配

1、创建一个Assets文件（或在现有的Assets文件中）

2、新建一个图片资源文件（或者颜色资源文件、或者其他资源文件）

3、选中该资源文件， 打开 Xcode ->View ->Inspectors ->Show Attributes Inspectors （或者Option+Command+4）视图，将Apperances 选项 改为Any，Dark

4、执行完第三步，资源文件将会有多个容器框，分别为 Any Apperance 和 Dark Apperance. Any Apperance 应用于默认情况（Unspecified）与高亮情况（Light）， Dark Apperance 应用于暗黑模式（Dark）

5、代码默认执行时，就可以正常通过名字使用了，系统会根据当前模式自动获取对应的资源文件

注意

同一工程内多个Assets文件在打包后，就会生成一个Assets.car 文件，所以要保证Assets内资源文件的名字不能相同
如何在代码里进行适配颜色（UIColor）

如何在代码里进行适配颜色（UIColor）

+ (UIColor *)colorWithDynamicProvider:(UIColor * (^)(UITraitCollection *))dynamicProvider API_AVAILABLE(ios(13.0), tvos(13.0)) API_UNAVAILABLE(watchos);
- (UIColor *)initWithDynamicProvider:(UIColor * (^)(UITraitCollection *))dynamicProvider API_AVAILABLE(ios(13.0), tvos(13.0)) API_UNAVAILABLE(watchos);

eg.

[UIColor colorWithDynamicProvider:^UIColor * _Nonnull(UITraitCollection * _Nonnull trait) {
    if (trait.userInterfaceStyle == UIUserInterfaceStyleDark) {
        return UIColorRGB(0x000000);
    } else {
        return UIColorRGB(0xFFFFFF);
    }
 }];

系统调用更新方法，自定义重绘视图

当用户更改外观时，系统会通知所有window与View需要更新样式，在此过程中iOS会触发以下方法, 完整的触发方法文档

UIView

traitCollectionDidChange(_:)
layoutSubviews()
draw(_:)
updateConstraints()
tintColorDidChange()

UIViewController

traitCollectionDidChange(_:)
updateViewConstraints()
viewWillLayoutSubviews()
viewDidLayoutSubviews()

UIPresentationController

traitCollectionDidChange(_:)
containerViewWillLayoutSubviews()
containerViewDidLayoutSubviews()

如何不进行系统切换样式的适配

注意
苹果官方强烈建议适配 暗黑模式（Dark Mode）此功能也是为了开发者能慢慢将应用适配暗黑模式

所以想通过此功能不进行适配暗黑模式，预计将会被拒

全局关闭暗黑模式

1、在Info.plist 文件中，添加UIUserInterfaceStyle key 名字为 User Interface Style 值为String，

2、将UIUserInterfaceStyle key 的值设置为 Light

单个界面不遵循暗黑模式

1、UIViewController与UIView 都新增一个属性 overrideUserInterfaceStyle
2、将 overrideUserInterfaceStyle 设置为对应的模式，则强制限制该元素与其子元素以设置的模式进行展示，不跟随系统模式改变进行改变
   1、设置 ViewController 的该属性， 将会影响视图控制器的视图和子视图控制器采用该样式
   2、设置 View 的该属性， 将会影响视图及其所有子视图采用该样式
   3、设置 Window 的该属性， 将会影响窗口中的所有内容都采用样式，包括根视图控制器和在该窗口中显示内容的所有演示控制器（UIPresentationController）

转自：https://www.jianshu.com/p/7925bd51d2d6

正文

笔者将通过不同经验程序员的技术视角来分析以上问题, 接下来开始我们的表演.

在开始代码之前我们先做好基础准备, 笔者先用nodejs搭建一个数据服务器, 提供基本的数据请求,核心代码如下:

app.use(async (ctx, next) => {
  if(ctx.url === '/api/getMock') {
    let list = []
    
    // 生成指定个数的随机字符串
    function genrateRandomWords(n) {
      let words = 'abcdefghijklmnopqrstuvwxyz你是好的嗯气短前端后端设计产品网但考虑到付款啦分手快乐的分类开发商的李开复封疆大吏师德师风吉林省附近',
          len = words.length,
          ret = ''
      for(let i=0; i< n; i++) {
        ret += words[Math.floor(Math.random() * len)]
      }
      return ret
    }

    // 生成10万条数据的list
    for(let i = 0; i< 100000; i++) {
      list.push({
        name: `xu_0${i}`,
        title: genrateRandomWords(12),
        text: `我是第${i}项目, 赶快🌀吧~~`,
        tid: `xx_${i}`
      })
    }

    ctx.body = {
      state: 200,
      data: list
    }
  }
  await next()
})

以上笔者是采用koa实现的基本的mock数据服务器, 这样我们就可以模拟真实的后端环境来开始我们的前端开发啦(当然也可以直接在前端手动生成10万条数据). 其中genrateRandomWords方法用来生成指定个数的字符串,这在mock数据技术中应用很多, 感兴趣的盆友可以学习了解一下. 接下来的前端代码笔者统一采用react来实现(vue同理).

初级工程师的方案

直接从后端请求数据, 渲染到页面的硬编码方案,思路如下:

代码可能是这样的:

1. 请求后端数据:

fetch(`${SERVER_URL}/api/getMock`).then(res => res.json()).then(res => {
  if(res.state) {
    data = res.data
    setList(data)
  }
})

2. 渲染页面

{
    list.map((item, i) => {
      return <div className={styles.item} key={item.tid}>
        <div className={styles.tit}>{item.title} <span className={styles.label}>{item.name}</span></div>
        <div>{item.text}</div>
      </div>
    })
}

3. 搜索数据

const handleSearch = (v) => {
    let searchData = data.filter((item, i) => {
      return item.title.indexOf(v) > -1
     })
     setList(searchData)
  }

这样做本质上是可以实现基本的需求,但是有明显的缺点,那就是数据一次性渲染到页面中, 数据量庞大将导致页面性能极具降低, 造成页面卡顿.

中级工程师的方案

作为一名有一定经验的前端开发工程师,一定对页面性能有所了解, 所以一定会熟悉防抖函数和节流函数, 并使用过诸如懒加载和分页这样的方案, 接下来我们看看中级工程师的方案：

通过这个过程的优化, 代码已经基本可用了, 下面来介绍具体实现方案:

1. 懒加载+分页方案 懒加载的实现主要是通过监听窗口的滚动, 当某一个占位元素可见之后去加载下一个数据,原理如下:

1. 这里我们通过监听window的scroll事件以及对poll元素使用getBoundingClientRect来获取poll元素相对于可视窗口的距离, 从而自己实现一个懒加载方案.

在滚动的过程汇总我们还需要注意一个问题就是当用户往回滚动时, 实际上是不需要做任何处理的,所以我们需要加一个单向锁, 具体代码如下:

function scrollAndLoading() {
    if(window.scrollY > prevY) {  // 判断用户是否向下滚动
      prevY = window.scrollY
      if(poll.current.getBoundingClientRect().top <= window.innerHeight) {
        // 请求下一页数据
      }
    }
}

useEffect(() => {
    // something code
    const getData = debounce(scrollAndLoading, 300)
    window.addEventListener('scroll', getData, false)
    return () => {
      window.removeEventListener('scroll', getData, false)
    }
  }, [])

其中prevY存储的是窗口上一次滚动的距离, 只有在向下滚动并且滚动高度大于上一次时才更新其值.

至于分页的逻辑, 原生javascript实现分页也很简单, 我们通过定义几个维度:

• curPage当前的页数


• pageSize 每一页展示的数量


• data 传入的数据量

有了这几个条件,我们的基本能分页功能就可以完成了. 前端分页的核心代码如下:

let data = [];
let curPage = 1;
let pageSize = 16;
let prevY = 0;

// other code...

function scrollAndLoading() {
    if(window.scrollY > prevY) {  // 判断用户是否向下滚动
      prevY = window.scrollY
      if(poll.current.getBoundingClientRect().top <= window.innerHeight) {
        curPage++
        setList(searchData.slice(0, pageSize * curPage))
      }
    }
}

2. 防抖函数实现 防抖函数因为比较简单, 这里直接上一个简单的防抖函数代码:

function debounce(fn, time) {
    return function(args) {
      let that = this
      clearTimeout(fn.tid)
      fn.tid = setTimeout(() => {
        fn.call(that, args)
      }, time);
    }
  }

3. 搜索实现 搜索功能代码如下:

const handleSearch = (v) => {
     curPage = 1;
     prevY = 0;
     searchData = data.filter((item, i) => {
        // 采用正则来做匹配, 后期支持前端模糊搜索
       let reg = new RegExp(v, 'gi')
       return reg.test(item.title)
     })
     setList(searchData.slice(0, pageSize * curPage))
}

需要结合分页来实现, 所以这里为了不影响源数据, 我们采用临时数据searchData来存储. 效果如下:

搜索后

无论是搜索前还是搜索后, 都利用了懒加载, 所以再也不用担心数据量大带来的性能瓶颈了~

高级工程师的方案

作为一名久经战场的程序员, 我们应该考虑更优雅的实现方式,比如组件化, 算法优化, 多线程这类问题, 就比如我们问题中的大数据渲染, 我们也可以用虚拟长列表来更优雅简洁的来解决我们的需求. 至于虚拟长列表的实现笔者在开头已经点过,这里就不详细介绍了, 对于更大量的数据,比如100万(虽然实际开发中不会遇到这么无脑的场景),我们又该怎么处理呢?

第一个点我们可以使用js缓冲器来分片处理100万条数据, 思路代码如下:

function multistep(steps,args,callback){
    var tasks = steps.concat();

    setTimeout(function(){
        var task = tasks.shift();
        task.apply(null, args || []);   //调用Apply参数必须是数组

        if(tasks.length > 0){
            setTimeout(arguments.callee, 25);
        }else{
            callback();
        }
    },25);
}

这样就能比较大量计算导致的js进程阻塞问题了.更多性能优化方案可以参考笔者之前的文章:

• web性能优化的15条实用技巧

我们还可以通过web worker来将需要在前端进行大量计算的逻辑移入进去, 保证js主进程的快速响应, 让web worker线程在后台计算, 计算完成后再通过web worker的通信机制来通知主进程, 比如模糊搜索等, 我们还可以对搜索算法进一步优化,比如二分法等,所以这些都是高级工程师该考虑的问题. 但是一定要分清场景, 寻找出性价比更高的方案.

链接：https://juejin.cn/post/6844904184689475592

可以看到，基本上耗时大户就是eslint-loader和vue-loader了，二者一个耗时40多秒，一个耗时30多秒，非常的占用资源。

接下来再看看具体的包分析👇

这一看就很一下子定位到问题到根源了，右侧的chunk-vendors不用看，只看左侧的chunk-page，这里面的页面数量太多了，相应的文件也很多，这也就直接导致了eslint-loader和vue-loader耗时很久了，这么多文件，一个个检查耗时当然久了。

右侧其实还可以继续优化，但感觉没必要，swiper其实并不大。

那么现在就可以具体定位到问题了，由于项目是多SPA应用，致使.vue文件众多，在项目启动时进行eslint检查和加载耗时过长，导致项目启动时间较久。

解决方案

找到问题之后就得解决问题了，初步的解决方案有两个：

1. 干掉eslint，在本地编译时不检查


2. 缓存

解决方案1必然是最简单的，但其实有点不合理，开着eslint就是为了规范代码格式，虽然在提交代码时也有对应的钩子来格式化代码，但在开发过程中进行提示可以更好的帮助我们形成合理的编码方式。

所以现在剩下的方案就只有进行缓存操作了，接下来笔者就开始找相关插件来更好的进行缓存了。

尝试解决

首先是hard-source-webpack-plugin，这插件为模块提供中间缓存步骤，但项目得跑两次，第一次构建时间正常，第二次大概能省去90%左右的时间。

这插件很多文章都有推荐，感觉很不错的样子，用起来也很简单，只需要👇：

plugins: [
  new HardSourceWebpackPlugin()
]

这就完事了。

就这么简单？确实是这么简单，但也不简单，如果到此为止，笔者也不会折腾一下午了。

就这么简单的一安装：

npm i hard-source-webpack-plugin -D

然后像👆一样简单的配置，然后重启项目，您猜怎么着？

报错了！

原因是什么呢？

是因为speed-measure-webpack-plugin或者webpack-bundle-analyzer中的某一个，为什么呢？

原因笔者其实并不太清楚，因为启动的时候报的错是这样的：

Cannot find module 'webpack/lib/DependenciesBlockVariable'

哦呦，这个错有点小意外，怎么会突然报webpack的错呢？

笔者也是百思不得其解啊，去Google也没有人遇到这种问题。

不得已，只能去hard-source-webpack-plugin的github上看issue，发现其实有人遇到这个问题的，他们的解决方案就是降低webpack的版本，可笔者这里没办法这么做，因为都集成在vue-cli里了，而且这个还是公司内部包了一层的，这就根本不可能降版本了。

第一个转机

那还能怎么办呢？

实在没有办法了，笔者尝试搜索DependenciesBlockVariable的相关内容，这时事情发生了一丝微妙的变换，原来这个功能在webpack5中被移除了，难道是因为公司内部的vue-cli用的是webpack5.x版本？

笔者当即在node_modules里面找到了插件，然后查看了package.json文件，结果失望的发现webpack的版本是4.2.6，这就令人绝望了，难道真的不可以么？

既然打开了webpack的文档，那就好好看看吧。老实说这文档笔者已经看了N次了，真是每次看都有小惊喜，功能真是太多了。

翻着翻着就看到了这个小功能👇：

哦呦，还真有点小惊喜呦，这功能简直了，这不就是我想要的么？然后当机立断，往vue.config.js里一家，您猜怎么着？

成了！

虽然文档是webpack5.0的，但笔者发现4.x版本中也有这个功能，可能若一弱一些吧，多少能用啊。

重启了几次项目后发现启动时间已经稳定了，效果真的还不错呦～

直接给我干到了14秒，虽然有些不太稳定，但这已经是当前状态的最好解决方案了。

所以最后的代码就是：

chainWebpack: (config) => {
  config.cache(true)
}

chainWebpack: (config) => {
  config.plugin('cache').use(HardSourceWebpackPlugin)
}

config.plugin('cache').use(HardSourceWebpackPlugin)

config.cache(true)

2019年度WWDC全球开发者大会，更新旗下用于手机、电脑、智能手表和电视机顶盒的软件操作系统。此外还发布了计算机编程语言框架SwiftUI。SwiftUI是基于开发语言Swift建立的框架——SwiftUI。全新的SwiftUI可以用于watchOS、tvOS、macOS等苹果旗下系统。

在本文对于SwiftUI使用做一个简介。😊

环境：

1、macOS 15 Beta
2、Xcode 11.0 Beta
3、iOS 13.0 Beta

接下来我们尝试体验一下SwiftUI功能，如何使用SwiftUI实现一个TableView呢？

import SwiftUI

struct Hero: Identifiable {
    let id: UUID = UUID()
    let name: String
}

struct ContentView : View {
    
    let heros = [
        Hero(name: "邱少云"),
        Hero(name: "黄继光"),
        Hero(name: "董存瑞"),
        Hero(name: "杨宝山"),
        Hero(name: "毛岸英")
    ]
    var body: some View {
        List(heros) {
            hero in
            Text(hero.name)
        }
    }
}

#if DEBUG
struct ContentView_Previews : PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}
#endif

以上是我们实现的第一个SwiftUI程序是不是很直观？
接下来我们来了解一下程序的入口，同时解释一下他们之间如何联系的。

1、创建一个SwiftUI 工程
在Xcode-Beta 里创建工程和之前Xcode版本是一样的，我们选择 Single View App：

给工程命名同时选择使用SwiftUI

2、了解程序的入口

让我们从项目中删除尽可能多的代码和文件，看到什么程度还可以让它跑起来。刚开始创建工程是这样的：

我们将AppDelegate.swift和ContentView.swift删除并移进回收站。并在SceneDelegate类的顶部添加@UIApplicationMain，让这个类遵循UIApplicationDelegate，删除SceneDelegate中除func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions)以外的方法，func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions)是程序的主入口。

现在如果选择iPhone XR进行运行，会显示黑屏。

3、创建一个新的Swift File或者直接选择SwiftUI View

我们将新创建的Swift文件命名为 AwesomeView.swift，内部代码如下，和我们最初删除的ContentView.swift内容一样：

import SwiftUI

struct AwesomeView : View {
    var body: some View {
        Text(/*@START_MENU_TOKEN@*/"Hello World!"/*@END_MENU_TOKEN@*/)
    }
}

#if DEBUG
struct AwesomeView_Previews : PreviewProvider {
    static var previews: some View {
        AwesomeView()
    }
}
#endif

AwesomeView.swift中有一个实现View协议的AwesomeView结构体，根据View协议，我们实现了body属性，Swift5.1中，我们不需要添加return关键字，函数或者闭包最后一行将自动返回。
这是我们写的第一个SwiftUI试图，接下来选择右上角，点击一个多条线按钮，选择Editor and Canvas

接下来点击Resume 或者 Try again 查看试图状态。
预览里将展示AwesomeView_Previews 结构体中闭包返回的所有试图预览。

在PreviewProvider里我们可以看到这段注释

Xcode statically discovers types that conform to `PreviewProvider` and
generates previews in the canvas for each provider it discovers.

通过Xcode静态发现符合PreviewProvider协议的类型，并在画布中为它发现的每个provider生成预览。所以我们可以随意命名xxx_Previews并遵循PreviewProvider协议，就可以在画布上预览我们的视图。
我们可以编辑左边的代码，看右侧的画布是不是可以重载。😍

4、将SwiftUI View 定义为程序启动图

之前我们的跑起来的程序是黑屏，目前重新启动程序依然是黑屏。如何将我们定义的为根视图呢？其实我们之前删除代码是我们就注意到了在SceneDelegate.swift中有以下代码：

import UIKit
import SwiftUI

@UIApplicationMain
class SceneDelegate: UIResponder, UIWindowSceneDelegate, UIApplicationDelegate {
    var window: UIWindow?
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // 实例化一个手机屏幕大小window
        let window = UIWindow(frame: UIScreen.main.bounds)
        // 实例化一个UIHostingController作为rootViewController
        // UIHostingController保存SwiftUI视图,将AwesomeView作为根视图
        window.rootViewController = UIHostingController(rootView: AwesomeView())
        self.window = window
        window.makeKeyAndVisible()
    }

}

现在运行程序我们就可以在模拟器中看到我们写的AwesomeView了。。。。

Xcode 是如何知道SceneDelegate.swift中的SceneDelegate作为程序启动根视图的类的呢？我们看一下工程中的info.plist

我们尝试修改一下Delegate Class Name将(PRODUCT_MODULE_NAME).SceneDelegate改为$(PRODUCT_MODULE_NAME).martinlasek,此时我们运行将会出现之前的黑屏情况，因为程序找不到martinlasek,
现在我们将SceneDelegate.swift中的SceneDelegate类重命名为martinlasek。然后我们再运行一次。在模拟器中我们再次看到了AwesomeView。
也就是说info.plist中的Delegate Class Name定义了根视图的类。

通过上面的一段内容你可以很轻松实现一个SwiftUI小程序。从现在开始你可以开启你的SwiftUI之旅了。

链接：https://www.jianshu.com/p/b4509d3d9766

上手初体验

刚开始上手时，推荐使用官方的脚手架创建项目，省时省心。

npx create-ink-app --typescript

然后运行这样一段代码:

import React, { useState, useEffect } from 'react'
import { render, Text} from 'ink'

const Counter = () => {
  const [count, setCount] = useState(0)
  useEffect(() => {
    const timer = setInterval(() => {
      setCount(count => ++count)
    }, 100)
    return () => {
      clearInterval(timer)
    }
    
  })

  return (
    <Text color="green">
      {count} tests passed
    </Text>
  )
}

render(<Counter />);

会出现如下的界面:

import { join, parse } from "path";
import { fdir } from 'fdir';
import fse from 'fs-extra'
const staticFiles = await new fdir() 
  .withFullPaths()   
  // 过滤掉 node_modules、ts、tsx
  .filter(
    (p) =>
      !p.includes('node_modules') &&
      !p.endsWith('.ts') &&
      !p.endsWith('.tsx')
  )
  // 搜索 src 目录
  .crawl(srcPath)
  .withPromise() as string[]

await Promise.all(staticFiles.map(file => {
  const targetFilePath = file.replace(srcPath, distPath);
  // 创建目录并拷贝文件
  return fse.mkdirp(parse(targetFilePath).dir)
    .then(() => fse.copyFile(file, distPath))
   );
}))

// index.tsx 引入代码省略
interface AppProps {
 fileConsumer: FileCopyConsumer
}

const ACTIVE_TAB_NAME = {
 STATE: "执行状态",
 LOG: "执行日志"
}

const App: FC<AppProps> = ({ fileConsumer }) => {
 const [activeTab, setActiveTab] = useState<string>(ACTIVE_TAB_NAME.STATE);
 const handleTabChange = (name) => {
  setActiveTab(name)
 }
 const WELCOME_TEXT = dedent`
  欢迎来到 \`ink-copy\` 控制台！功能概览如下(按 **Tab** 切换):
 `

 return <>
   <FullScreen>
    <Box>
     <Markdown>{WELCOME_TEXT}</Markdown>
    </Box>
    <Tabs onChange={handleTabChange}>
     <Tab name={ACTIVE_TAB_NAME.STATE}>{ACTIVE_TAB_NAME.STATE}</Tab>
     <Tab name={ACTIVE_TAB_NAME.LOG}>{ACTIVE_TAB_NAME.LOG}</Tab>
    </Tabs>
    <Box>
     <Box display={ activeTab === ACTIVE_TAB_NAME.STATE ? 'flex': 'none'}>
      <State />
     </Box>
     <Box display={ activeTab === ACTIVE_TAB_NAME.LOG ? 'flex': 'none'}>
      <Log />
     </Box>
    </Box>
   </FullScreen>
 </>
};

export default App;

export interface EventData {
  kind: string;
  payload: any;
}

export class FileCopyConsumer {

  private callbacks: Function[];
  constructor() {
    this.callbacks = []
  }
  // 供 React 组件绑定回调
  onEvent(fn: Function) {
    this.callbacks.push(fn);
  }
  // 文件操作完成后调用
  onDone(event: EventData) {
    this.callbacks.forEach(callback => callback(event))
  }
}

export class FileOperator {
  fileConsumer: FileCopyConsumer;
  srcPath: string;
  targetPath: string;
  constructor(srcPath ?: string, targetPath ?: string) {
    // 初始化 EventBus 对象
    this.fileConsumer = new FileCopyConsumer();
    this.srcPath = srcPath ?? join(process.cwd(), 'src');
    this.targetPath = targetPath ?? join(process.cwd(), 'dist');
  }

  async copyFiles() {
    // 存储 log 信息
    const stats = [];
    // 在 src 中搜索文件
    const staticFiles = ...
    
    await Promise.all(staticFiles.map(file => {
        // ...
        // 存储 log
        .then(() => stats.push(`Copied file from [${file}] to [${targetFilePath}]`));
    }))
    // 调用 onDone
    this.fileConsumer.onDone({
      kind: "finish",
      payload: stats
    })
  }
}

// 组件当中拿到 fileConsumer & 绑定回调
export const State: FC<{}> = () => {
  const context = useContext(Context);
  const [finish, setFinish] = useState(false);
  context?.fileConsumer.onEvent((data: EventData) => {
    // 下面的逻辑在文件拷贝完成后执行
    if (data.kind === 'finish') {
      setTimeout(() => {
        setFinish(true)
      }, 2000)
    }
  })

  return 
  //(JSX代码)
}

什么是单一责任原则？

单一责任原则告诉我们的是，每个类或组件应该有一个单一的存在目的。

组件应该只做一件事，并且做得很好。

让我们重构一段糟糕但正常工作的代码，并使用这个原则使其更加清晰和完善。

让我们从一个糟糕的例子开始

首先让我们看看一些违反这一原则的代码，添加注释是为了更好地理解:

import React, {useEffect, useReducer, useState} from "react";

const initialState = {
    isLoading: true
};

// 复杂的状态管理
function reducer(state, action) {
    switch (action.type) {
        case 'LOADING':
            return {isLoading: true};
        case 'FINISHED':
            return {isLoading: false};
        default:
            return state;
    }
}

export const SingleResponsibilityPrinciple = () => {

    const [users , setUsers] = useState([])
    const [filteredUsers , setFilteredUsers] = useState([])
    const [state, dispatch] = useReducer(reducer, initialState);

    const showDetails = (userId) => {
        const user = filteredUsers.find(user => user.id===userId);
        alert(user.contact)
    }

    // 远程数据获取
    useEffect(() => {
        dispatch({type:'LOADING'})
        fetch('https://jsonplaceholder.typicode.com/users')
            .then(response => response.json())
            .then(json => {
                dispatch({type:'FINISHED'})
                setUsers(json)
            })
    },[])

    // 数据处理
    useEffect(() => {
        const filteredUsers = users.map(user => {
            return {
                id: user.id,
                name: user.name,
                contact: `${user.phone} , ${user.email}`
            };
        });
        setFilteredUsers(filteredUsers)
    },[users])

    // 复杂UI渲染
    return <>
        
 Users List

        
 Loading state: {state.isLoading? 'Loading': 'Success'}

        {users.map(user => {
            return 
 showDetails(user.id)}>
                
{user.name}

                
{user.email}

            

        })}
    
}

这段代码的作用

这是一个函数式组件，我们从远程数据源获取数据，再过滤数据，然后在 UI 中显示数据。我们还检测 API 调用的加载状态。

为了更好地理解这个例子，我把它简化了。但是你几乎可以在任何地方的同一个组件中找到它们！这里发生了很多事情:

1. 远程数据的获取

2. 数据过滤

3. 复杂的状态管理

4. 复杂的 UI 功能

import {useEffect, useReducer, useState} from "react";

const initialState = {
    isLoading: true
};

function reducer(state, action) {
    switch (action.type) {
        case 'LOADING':
            return {isLoading: true};
        case 'FINISHED':
            return {isLoading: false};
        default:
            return state;
    }
}

export const useGetRemoteData = (url) => {

    const [users , setUsers] = useState([])
    const [state, dispatch] = useReducer(reducer, initialState);

    const [filteredUsers , setFilteredUsers] = useState([])


    useEffect(() => {
        dispatch({type:'LOADING'})
        fetch('https://jsonplaceholder.typicode.com/users')
            .then(response => response.json())
            .then(json => {
                dispatch({type:'FINISHED'})
                setUsers(json)
            })
    },[])

    useEffect(() => {
        const filteredUsers = users.map(user => {
            return {
                id: user.id,
                name: user.name,
                contact: `${user.phone} , ${user.email}`
            };
        });
        setFilteredUsers(filteredUsers)
    },[users])

    return {filteredUsers , isLoading: state.isLoading}
}

import React from "react";
import {useGetRemoteData} from "./useGetRemoteData";

export const SingleResponsibilityPrinciple = () => {

    const {filteredUsers , isLoading} = useGetRemoteData()

    const showDetails = (userId) => {
        const user = filteredUsers.find(user => user.id===userId);
        alert(user.contact)
    }

    return <>
        
 Users List

        
 Loading state: {isLoading? 'Loading': 'Success'}

        {filteredUsers.map(user => {
            return 
 showDetails(user.id)}>
                
{user.name}

                
{user.email}

            

        })}
    
}

import {useEffect, useReducer, useState} from "react";
import {loadingReducer} from "./LoadingReducer";

const initialState = {
    isLoading: true
};

export const useHttpGetRequest = (URL) => {

    const [users , setUsers] = useState([])
    const [state, dispatch] = useReducer(loadingReducer, initialState);

    useEffect(() => {
        dispatch({type:'LOADING'})
        fetch(URL)
            .then(response => response.json())
            .then(json => {
                dispatch({type:'FINISHED'})
                setUsers(json)
            })
    },[])

    return {users , isLoading: state.isLoading}

}