javascript复制代码let fn = function () {
	console.log('hello world')
}

function copy (fn) {
	let foo = fn.toString()
	return new Function(`return ${foo}`).call(fn)
}

let foo = copy(fn)
foo() // hello world

vbnet复制代码function deepCopy(obj) {
    const objCopy = Array.isArray(obj) ? [] : {}
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            if (obj[key] instanceof Object) {
                objCopy[key] = deepCopy(obj[key])
            } else {
                objCopy[key] = obj[key]
            }
        }
    }
    return objCopy
}

javascript复制代码let obj = {
    a: {
        b: 1
    }
}

function deepCopy(obj) {
    return new Promise((resolve) => {
        const { port1, port2 } = new MessageChannel() // 对象解构的key不能乱写
        port1.postMessage(obj) // 喊话obj
    
        obj.a.b = 2 // 测试深拷贝
    
        port2.onmessage = function (msg) { // msg就是port1喊话的内容
            resolve(msg.data) // msg被包裹了一层data
        }
    })
}

async function fn () {
    let objCopy = await deepCopy(obj)
    console.log(objCopy);
}

fn() // { a: { b: 1 } }

go复制代码func worker(c context.Context, wg *sync.WaitGroup, id int) {

   defer wg.Done()

   select {
   case <-time.After(time.Second):
      fmt.Sprintln("执行完成 %", id)
   case <-c.Done():
      fmt.Sprintln("请求超时 %", id)
   }
}

func main() {

   ctx, cancel := context.WithTimeout(context.Background(), time.Second)
   defer cancel()

   var wg sync.WaitGroup
   wg.Add(1000)

   for i := 0; i < 1000; i++ {
      go worker(ctx, &wg, i)
   }

   wg.Wait()
}

go复制代码func main() {
   a := []int{1, 2, 3}
   b := a[:2]

   b = append(b, 4)
   fmt.Println(a)  // 1,2,4,3

   b = append(b, 5)
   fmt.Println(a)  // 1,2,5,4,3

   b[0] = 10
   fmt.Println(a)  // 1,2,10,4,3
}

kotlin复制代码data class Todo(val name: String, val id: String)

sealed interface TodoAction
data class AddTodo(val todo: Todo) : TodoAction
data class DelTodo(val id: String) : TodoAction

val todoReducer: Reducer<List<Todo>, TodoAction> = { prevState: List<Todo>, action: TodoAction ->
    when (action) {
        is AddTodo -> buildList {
            addAll(prevState)
            add(action.todo)
        }
        is DelTodo ->  prevState.filter { it.id != action.id }
    }
}

val store = createStore {
    todoReducer with emptyList() // 使用中缀函数 with 来连接reducer函数与初始状态
}

@Composable
fun UseReduxExample() {
    ReduxProvider(store = store) {
      
    }
}

kotlin复制代码@Composable
fun TodoList() {
    val todos = useSelector<List<Todo>>() //需要传递 状态 的类型
    Column {
        todos.map {
            TodoItem(item = it)
        }
    }
}

kotlin复制代码@Composable
fun Header() {
    val dispatch = useDispatch<TodoAction>() //需要传递 Action 的类型
    val (input, setInput) = useState("")
    Row {
        OutlinedTextField(
            value = input,
            onValueChange = setInput,
        )
        TButton(text = "add") {
            dispatch(AddTodo(Todo(input, NanoId.generate())))
            setInput("")
        }
    }
}


@Composable
fun TodoItem(item: Todo) {
    val dispatch = useDispatch<TodoAction>()
    Row(modifier = Modifier.fillMaxWidth()) {
        Text(text = item.name)
        TButton(text = "del") {
            dispatch(DelTodo(item.id))
        }
    }
}

kotlin复制代码val store = createStore {
    otherReducer with OtherData("default", 18) //另一个 reducer
    todoReducer with emptyList()
}

scss复制代码implementation("xyz.junerver.compose:hooks:1.0.8")

bash复制代码# 创建目录
mkdir my-project

# 进入
cd my-project

# 初始化
pnpm init

bash复制代码touch pnpm-workspace.yaml

markdown复制代码packages:
  - packages/*
  - playground
  - docs

bash复制代码mkdir packages

mkdir packages/vue

cd packages/vue

pnpm init

bash复制代码# 安装到 my-project 根目录下
pnpm i typescript @types/node -Dw 

# 初始化 
npx tsc --init

bash复制代码touch README.md LICENSE

bash复制代码pnpm i eslint @antfu/eslint-config -Dw

php复制代码import antfu from '@antfu/eslint-config'

export default antfu({
  ignores: ['/dist', '/node_modules', '/packages/**/dist', '/packages/**/node_modules'],
  rules: {
    '@typescript-eslint/no-non-null-asserted-optional-chain': 'off',
    '@typescript-eslint/ban-ts-comment': 'warn',
    '@typescript-eslint/consistent-type-definitions': 'off',
    'import/first': 'off',
    'import/order': 'off',
    'symbol-description': 'off',
    'no-console': 'warn',
    'max-statements-per-line': ['error', { max: 2 }],
    'vue/one-component-per-file': 'off',
  },
})

bash复制代码"lint": "eslint .",
"lint:fix": "eslint . --fix",

bash复制代码pnpm i simple-git-hooks lint-staged -Dw

json复制代码script:{
  "prepare": "npx simple-git-hooks",
},
"lint-staged": {
    "*": "eslint --fix"
}

bash复制代码pnpm i @commitlint/config-conventional @commitlint/cli -Dw

json复制代码"commitlint": {
    "extends": [
      "@commitlint/config-conventional"
    ]
},
"simple-git-hooks": {
    "pre-commit": "pnpm lint-staged",
    "commit-msg": "pnpm commitlint --edit ${1}"
  },

bash复制代码# 进入目录
cd package/vue

# 初始化
pnpm init

bash复制代码pnpm install vue vue-tsc -D

bash复制代码pnpm install @vueuse/core -D

bash复制代码pnpm install typescript @tsconfig/node18 @vue/tsconfig -D

json复制代码{
  "files": [],
  "extends": ["./tsconfig.app.json"]
}

json复制代码{
  "extends": "@vue/tsconfig/tsconfig.dom.json",
  "include": [
    "env.d.ts",
    "src/**/*",
    "src/**/*.ts",
    "src/**/*.tsx",
    "src/**/*.vue"
  ],
  "compilerOptions": {
    "paths": {
      "@/*": ["src/*"],
    },
    "target": "esnext",
    "module": "esnext",
    "moduleResolution": "node",
    "strict": true,
    "jsx": "preserve",
    "sourceMap": true,
    "resolveJsonModule": true,
    "esModuleInterop": true,
    "declaration": false,
    "lib": ["esnext", "dom"],
    "baseUrl": ".",
    "skipLibCheck": true,
    "outDir": "dist"
  }
}

json复制代码{
  "extends": "@tsconfig/node18/tsconfig.json",
  "include": [
    "vite.config.*",
    "vitest.config.*",
    "cypress.config.*",
    "nightwatch.conf.*",
    "playwright.config.*"
  ],
  "compilerOptions": {
    "composite": true,
    "module": "ESNext",
    "types": ["node"]
  }
}

bash复制代码pnpm install vite @vitejs/plugin-vue vite-plugin-dts -D

ts复制代码import { resolve } from 'node:path'
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import dts from 'vite-plugin-dts'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [
    vue(),
    dts({
        tsconfigPath: 'tsconfig.build.json',
        cleanVueFileName: true,
        exclude: ['src/test/**'],
      }),
  ],

  build: {
    lib: {
      name: 'yi-ui',
      fileName: 'index',
      entry: resolve(__dirname, 'src/index.ts'),
    },
  },
})

bash复制代码mkdir src 

touch src/index.ts

ts复制代码const a = '1111'

const b = '2222'

const fn = () => {
    console.log('fn')
}

const add = (a: number, b: number) => {
    return a + b
}

export { a, b, fn, add }

json复制代码"build": "vite build",

bash复制代码pnpm build

json复制代码"exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "require": "./dist/index.umd.js",
      "import": "./dist/index.mjs"
    }
},
"main": "./dist/index.umd.js",
"module": "./dist/index.mjs",
"types": "./dist/index.d.ts",
"typings": "./dist/index.d.ts",

ts复制代码import { add } from '@yi-ui/vue'

add(1, 2)

bash复制代码cs package/vue

pnpm install vitest -D

ts复制代码import { resolve } from 'node:path'
import { defineConfig } from 'vitest/config'
import Vue from '@vitejs/plugin-vue'

const r = (p: string) => resolve(__dirname, p)

export default defineConfig({
  plugins: [Vue()],
  resolve: {
    alias: {
      '@': r('./src'),
    },
  },
})

bash复制代码"script": {
    ...
    "test": "vitest",
    ...
}

ts复制代码import { describe, expect, test, it } from 'vitest'
import { add } from './index'

describe('测试', () => {
    test('函数返回值', () => {
        expect(add(1, 2)).toBe(3)
    })
})

bash复制代码mkdir docs

cd docs 

pnpm init

bash复制代码pnpm i vitepress tailwindcss -D

bash复制代码"scripts": {
    "docs:dev": "vitepress dev",
    "docs:build": "vitepress build",
    "docs:preview": "vitepress preview"
  },

bash复制代码mkdir playground

cd playground

bash复制代码
pnpm create vite

bash复制代码
pnpm create vite

# 选择 nuxt

json复制代码"dependencies": {
    "@yi-ui/vue": "link:../../packages/vue",
},

ts复制代码import { add } from '@yi-ui/vue'

add(1, 2)

json复制代码"scripts": {
    "clear": "rimraf packages/**/dist",
    "build": "pnpm run clear && pnpm -r --filter=./packages/** run build",
},

bash复制代码pnpm install rimraf -Dw

bash复制代码pnpm build

bash复制代码npm login

css复制代码pnpm i @changesets/cli -Dw

csharp复制代码pnpm changeset init

lua复制代码|-- my-project
    |-- .changeset
        |-- config.json
        |-- README.md
    |-- ...

json复制代码{
  "$schema": "https://unpkg.com/@changesets/config@3.0.0/schema.json",
  "changelog": "@changesets/cli/changelog",
  "commit": false,
  "fixed": [],
  "linked": [],
  "access": "public",
  "baseBranch": "main",
  "updateInternalDependencies": "patch",
  "ignore": [
    "@yi-ui/playground",
    "@yi-ui/docs"
  ]
}

json复制代码{
    "script": {
        // 1. 开始交互式填写变更集，每次发布版本的时候执行，生成对应的 md 文件
        "changeset": "changeset",
        // 2. 用来统一提升版本号以及对应的md文档
        "vp": "changeset version",
        // 3. 构建产物后发版
        "release": "pnpm build && pnpm release:only",
        "release:only": "changeset publish"
    }
}

bash复制代码pnpm install @yi-ui/vue

ts复制代码import { add } from '@yi-ui/vue'

add(1, 2)

js复制代码// server.js
const express = require("express");
const { createProxyMiddleware } = require("http-proxy-middleware");
const path = require("path");
const compression = require("compression");
const app = express();

app.use(compression());

// 静态资源服务
app.use(express.static(path.join(__dirname, "./src/main/webapp")));

// 接口转发
app.use(
  "/draw-io",
  createProxyMiddleware({
    target: "http://draw.eztool.top",
    changeOrigin: true,
    pathRewrite: {
      "^/draw-io": "/draw-io", // 转发的时候去掉前缀
    },
  })
);

// 启动服务器
const port = 3000;
app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});

css复制代码  location ~* \.(js|css|html)$ {
        add_header cache-control no-cache;
    }

js复制代码export const openDraw = (id) => {
  const dev = location.href.includes("localhost");
  let url;
  if (dev) {
    url = `http://localhost:3000?dev=1&id=${id}`;
  } else {
    url = `http://draw.eztool.top/draw?id=${id}`;
  }
  window.open(url);
};

java复制代码
@Slf4j
@UtilityClass
public class JwtUtil {

    String jwtStr  = "xxxxxxx";

    public String getToken(User user) {
        return JWTUtil.createToken(BeanUtil.toBean(user,Map.class), jwtStr.getBytes());
    }

   public Boolean verify(String token) {
       return JWTUtil.verify(token, jwtStr.getBytes());
   }


   public void isLogin(String token){
        if (StrUtil.isBlank(token)) {
            throw new BusinessException("请先登录");
        }
        if (!verify(token)) {
            throw new BusinessException("请先登录");
        }
   }

   public User getUser(String token){
       isLogin(token);
       JWTPayload payload = JWTUtil.parseToken(token).getPayload();
       if (Objects.isNull(payload)){
           throw new BusinessException("用户信息为空");
       }
       return User.tpJWTPayload(payload);
   }

}

json复制代码{
    "userId": "",
    "ip": "",
    "name": "",
    "account": "",
    "password": "",
    "id": "",
    "createTime": "",
    "updateTime": ""
}

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

yml复制代码spring:
  mail:
    # 设置邮箱主机
    host: smtp.163.com
    # SMTP 服务器的端口
    port: 587
    # 设置用户名，这里使用你邮箱账号就行
    username: 123456789@163.com
    # 设置密码，该处的密码是邮箱开启SMTP的授权码而非邮箱密码
    password: SODJSHAUHGQWRQWE
    default-encoding: UTF-8
    protocol: smtps
    properties:
      mail:
        smtp:
          ssl:
            enable: true

java复制代码@Slf4j
@Service
@RequiredArgsConstructor
public class MailServiceImpl  implements MailService {

    private final JavaMailSender javaMailSender;
    
    //发送邮件
    @Override
    public void sendEmail(String email,String subject, String text) {
        try {
            SimpleMailMessage mailMessage = new SimpleMailMessage();
            //你的邮箱账号
            mailMessage.setFrom("123456789@163.com");
            //接收方的邮箱账号
            mailMessage.setTo(email);
            //标题
            mailMessage.setSubject(subject);
            //内容
            mailMessage.setText(text);
            //发送邮件
            javaMailSender.send(mailMessage);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("发送邮箱失败:{}",e.getMessage());
        }
    }

}

json复制代码{
    "fileId": "", //文件ID
    "parentId": "", //上级文件id
    "name": "", //名称
    "type": "", //文件类型 0=文件 1=文件夹
    "content": "", //文件内容
    "isSub": false, //是否有下级（针对文件夹点击下拉判断）
    "createId": "", //创建用户id
    "updateId": "", //修改用户id
    "delFlag": "", //逻辑删除 0=正常 1=删除
    "id": "",
    "createTime": "",
    "updateTime": ""
}

js复制代码// 初始化
Track.init({
  debug: false,
  appId: 1,
  initialExtra: () => {
    return {
	  // 强行覆盖默认的 appId，用于微应用中识别子应用
      appId: getCurrentApp()?.appId || 1,
      userId,
    };
  },
  integrations: {
    InstrumentTrack: {
      enable: false,
      option: {},
    },
  },
});

// 埋点，两种埋点方式，对于无需参数的可以快捷埋点
function submitTrack(eventName: string, options?: { extends?: any }): void;
function submitTrack({
	et: string;
	e_name: string;
	extends?: any;
}): void;

// 日志，消息内容会被 stringify
interface logger {
	error(msg: any): void;
	warn(msg: any): void;
	info(msg: any): void;
}

js复制代码// paylaod
{
    "m": [
        {
            "time": 1710123186431,
            "referer": "http://localhost:3000/",
            "type": "log",
            "data": {}
        }
    ],
    "c": {
        "appId": 382,
        "env": "prod",
        "app": "",
        "app_version": "",
        "platform": "",
        "platform_version": "",
        "model": "",
        "brand": "",
        "userId": "123",
        “track”: {}
    }
}
// response header
Track-Id: 111111aaaaaa222222bbbbbb
X-Track: a=1;b=25;c=31;d=0

ts复制代码// core
class SDK {
	static get instance(): SDK;
	// 实例化方法，sdk实例会存在 global 中，避免多次初始化导致重复埋点
	static init(option) {
	    try {
	      _global.__sdk_instance_ = new SDK(option);
	    } catch (error) {
	      console.error('sdk init error: ', error);
	    }
	}
	// 远程配置管理  
	readonly configurator: Configurator;  
	// SDK 上报器  
	readonly reporter: Reporter;
	// 各种内置模块
	...
	// 插件列表  
	private integrations: Record<string, Integration> = {};
	constructor(
		this.configurator = new Configurator(this);
		this.extraInfo = new ExtraInfo(this);
		// 初始化各种模块 & 加载插件
		...
		const totalSwitch = this.initIntegration();
	    /** 全局开关关闭时或有插件关闭时，强制刷新配置 */
	    const { report } = configurator.configuration;
	    if (report === false || (typeof report === 'number' && report !== totalSwitch)) {
	      configurator.forceUpdate();
	    }
	)
	// 各种工具函数
	...
}

// 提供便捷的上报日志和埋点的方法
export function logger(): Logger;
export function submitTrack(): SubmitTrack;

// platform

const DEFAULT_INTEGRATIONS = [
  InstrumentBehavior,
  InstrumentApi,
  InstrumentStatic,
  InstrumentTrack,
  IntegrationCacheData,
];

export init = (options) => {
	// 处理options，添加默认值，转换参数格式等
    SDK.init({
	    ...options,
	    transport,
	    corssPlatform,
	    integrations(this) {
		    return convertOptionsToIntegrations.call(this, DEFAULT_INTEGRATIONS, options.integrations);
	    },
	    initialExtra: () => inheritData(env.getTags.bind(env), initialExtra)
    });
}

ts复制代码class Configurator {
	private configuration: Configuration = {};
	private stringConfiguration = '';
	private storage: Required<CrossPlatform>['storage'];
	/** 强制刷新配置 */
	forceUpdate(): void;
	/** 格式化配置 */
	parse(input?: string, disableCache = false): Configuration;
	/** 获取具体配置 */
	get(key: string | string[]): any | Record<string, any>;
}

ts复制代码// Report & Queue是sdk的核心模块
class Reporter {
	private queue: Queue;
	getQueue(): Queue;
	send(data: Data, options: {lazy?: boolean; reportType?: number});
	private disabledReport(reportType?: number): boolean;
}

class Queue {
	/** 普通队列 */
	private stack = [];
	/** 历史紧急上报队列信息 */
	private immediatelyStack = [];
	/** 采样队列 */
	private samplingList = [];

	/** 是否正在上报 */
	private isFlushing = false;
	private readonly micro: Promise<any>;
	/** 上报任务轮训 */
	private timer: NodeJS.Timer | null = null;
	/** 异常重试次数 */
	private retryTimes = 0;
	/** 添加队列，包含采样等逻辑 */
	add(rawData: data, options: {lazy?: boolean}): void;
	/** 上报数据（理论外部不允许使用） */
	report(data: Item[], options?: {lazy?: boolean}): void;
	/** 获取当前堆栈 */
	getStack(): Item[];
	/** 添加上报轮训任务 */
	private addListener(): void;
	/** 添加队列时预处理上报信息 */
	private generateStackItem(data: data): Item;
	/** 采样上报队列 */
	private sampling(data: Item): Item | undefined;
	/** 添加队列 */
	private _add(data: Item, lazy = true): void;
	/** 是否需要延迟上报 */
	private isLazy(lazy = true): boolean;
	/** 轮训任务 */
	private loop(time = 10000): void;
	/** 清空某一种日志类型的采样队列并获取采样 */
	private flushSampleItem(type: string, force = false): void;
	/** 清空所有采样队列并获取采样 */
	private flushSample(): void;
	/** 清空普通队列并上报 */
	private flushStack(): void;
}

ts复制代码(_integrations ?? []).forEach((Integration) => {  
	try {  
	const integrationInstance =  
	typeof Integration === 'object' ? Integration : new Integration(this);  
	  
	integrationInstance.instrument();  
	this.integrations[Integration.constructor.name] = integrationInstance;  
	totalSwitch += integrationInstance.reportType || 0;  
	} catch (error: any) {  
	console.error(error);  
	this.logger.error(error?.message, 'sdk_error');  
	}  
})

ts复制代码class Cache {
	/** 初始化插件，db等 */
	instrument(): void;
	/** 监听关闭事件，缓存堆栈 */
	addUnloadEvent(db: DB): void;
	/** 初始化时添加堆栈 */
	reInsertPrevList(db: DB): void;
}
class DB {
	static isSupport: boolean = !!(_global && _global.indexedDB);  
	private db?: DBDatabase;
	connect(options: {name: string; version?: number; tableSchema: Record<string, string | undefined>;}): Promise<void>; 
	getAll<E = any>(tableName: string): Promise<E[]>
	batchAdd(tableName: string, value: any, key?: string): Promise<void>
	clear(table: string): Promise<void>;
}

ts复制代码const observer = new PerformanceObserver((list) => {
	// 处理资源
})
try {
	observer.observe({type: 'resource', buffer: true});
} catch () {
	observer.observe({ entryTypes: ['resource'] });
}

ts复制代码interface PluginOptionElement {  
	/** 唯一key */  
	identity: string;  
	/** 需要修改的元素的名称 */  
	name: string | RegExp | ((pathName: string, path: NodePath) => boolean);  
	/** 需要修改的属性的名称，仅修改属性时生效 */  
	attribute?: string;  
	/** 需要添加的属性或父元素的ast的模版 */  
	template: string | TemplateFn;  
	/** 需要import的依赖 */  
	require?: [];  
}

/** 获取继承了原有方法的函数 */  
export const getInheritFn = (attribute: string, attributes: Record<string, Node> = {}): string => {  
	if (!attribute) {  
		return '';  
	}  
	const spreadAttributes = getSpreadAttribute(attributes);  
	const inheritFn = attributes[attribute];  
	if (!spreadAttributes?.length) {  
		return inheritFn ? `%%${attribute}%%(event);` : '';  
	}  
	  
	const params = (  
		!inheritFn  
			? spreadAttributes  
			: [
				...spreadAttributes,  
				{
					name: `%%${attribute}%%(event)`,  
					index: (inheritFn as any)._attr_index,  
				},  
			  ]  
		)  
	.sort((a, b) => a.index - b.index)  
	.map(({ name }) => name)  
	.join(',');  
	  
	return `_execInheritFn(event, "${attribute}", ${params})`;  
};

// demo
const getTriggerFn = (attributes: Record<string, Node>) => {  
	return `  
	(event) => {  
		_gem_t('img:error', event);  
		${getInheritFn('onError', attributes)}  
	}  
	`;  
};  
  
export const imgErrorInjectConfig = {  
	identity: 'img-error',  
	name: 'Image',  
	attribute: 'onError',  
	template: (attributes) => getTriggerFn(attributes),  
	require: ['import { trigger as _gem_t, _execInheritFn } from "@guming/global-event-mini"'],  
};

ts复制代码class Track {
	instrument() {
		initTrack({  
			...options!,  
			eventQueueLimitNum: 1,  
			request: ({ data }) => {  
				this.report({  
					type: MeasurementType.Track,  
				data,  
				});  
			},  
		});
		sdk.extraInfo.addExtra('track', () => {  
			return trackStore.getCommonInfo();  
		});
		this.trackClick();
	}

	/** 劫持点击，有 data-track-option 属性的元素点击事件自动埋点 */
	private trackClick(): void;
}

text复制代码Perplexity AI 提供类似于 Google Search 和 Bing Search 的搜索服务，用户可以用自然语言输入问题，可以获得类似于 ChatGPT 的答案。

sh复制代码[shishu@hadoop1]$ export B=su7
[shishu@hadoop1]$ echo $B
[shishu@hadoop1]$ cat helloworld.sh
echo "helloworld'
echo $B
[shishu@hadoop1]$ sh helloworld.sh
helloword
su7

shell复制代码[root@clb1 shell]# cat teshu.sh
#!/bin/bash
#传参个数
echo $#
#参数输出
echo "$0 $1 $2"
[root@clb1 shell]# sh teshu.sh xiaomi su7
2
teshu.sh xiaomi su7

sh复制代码echo $?

sh复制代码#!/bin/bash
A=100
B=2
#第一种写法
C=$((A+B))
#第二种
D=$[A+B]
#第三种
E=`expr $A + $B`
echo $E

#综合运算(2+3)*5
F=$[(2+3)*5]
#expr `expr 2+3` * 5 
echo $F

sh复制代码[root@clb1 shell]# cat luoji.sh
#!/bin/bash
#&& 逻辑与 和 逻辑或
echo $#
[ $# -gt 2 ] && echo "参数的个数大于2"
[ $# -lt 2 ] || echo "参数的个数大于2----"
[root@clb1 shell]# sh luoji.sh 1 2 3
3
参数的个数大于2
参数的个数大于2----
[root@clb1 shell]# sh luoji.sh 1 2
2
参数的个数大于2----
[root@clb1 shell]# sh luoji.sh 1
1

sh复制代码#!/bin/bash
#如果用户zhangsan不存在，则添加用户zhangsan
id zhangsan &> /dev/null && echo "zhangsan用户存在，不用添加"
id zhangsan &> /dev/null || useradd zhangsan

sh复制代码if [ 条件判断句 ];then
    程序
fi

#或者

if [ 条件判断句 ]
    then
    程序
fi

sh复制代码[root@clb1 shell]# cat if.sh
#!/bin/bash
if [ $1 -lt 18 ];then
    echo "未成年"
elif [ $1 -ge 18 -a $1 -le 30 ];then
    echo "青年"
else
    echo "中老年"
fi
[root@clb1 shell]# sh if.sh 22
青年
[root@clb1 shell]# sh if.sh 33
中老年
[root@clb1 shell]# sh if.sh 3
未成年

sh复制代码case $变量名 in
  “值1”)
    如果变呈的值等于值1，则执行程序1
    ;;
  “值2”)
    如果变星的值等于值2，则执行程序2
    ;;
  *)
    如果变量的值都不是以上的值，则执行此程序
    ;;
esac

sh复制代码[root@clb1 shell]# cat case.sh
#!/bin/bash
case $1 in
"start")
    echo "你输入的是start"
;;
"stop")
    echo "你输入的是stop"
;;
*)
    echo "你输入的是其他"
;;
esac
[root@clb1 shell]# sh case.sh stop
你输入的是stop
[root@clb1 shell]# sh case.sh start
你输入的是start
[root@clb1 shell]# sh case.sh st
你输入的是其他

sh复制代码for ((初始值;循环控制条件;变量变化))
 do
    程序
 done

sh复制代码#!/bin/bash

for ((i=0;i<=100;i++));do
     s=$[$s+$i]
done

echo "1到100的和是$s"

sh复制代码for 变量 in 值1 值2 值3...
 do
    程序
 done

sh复制代码[root@clb1 shell]# cat sum100.2.sh
#!/bin/bash
for i in {1..100};do
    s=$[$s+$i]
done
echo "1到100的和是$s"

sh复制代码[root@clb1 shell]# cat sum100.2.sh
#!/bin/bash
for i in `seq 1 100`;do
    s=$[$s+$i]
done
echo "1到100的和是$s"

sh复制代码[root@clb1 shell]# cat file.sh
#!/bin/bash
for i in `ls /root`;do
    echo $i
done

sh复制代码[root@clb1 shell]# cat qufen.sh
 #先测试$*
for i in "$*";do
    echo "传入脚本的参数是:$i"
done
echo "--------------"
#测试$@
for j in "$@";do
    echo "传入脚本的参数是:$j"
done
[root@clb1 shell]# sh qufen.sh 123 321
传入脚本的参数是:123 321
--------------
传入脚本的参数是:123
传入脚本的参数是:321

sh复制代码[root@clb1 shell]# cat sum100.3.sh
#!/bin/bash
i=1
sum=0
while [ $i -le 100 ];do
    let sum=sum+i
    #这行代码也可以写成:sum=$[$sum+$i]
    let i++
done
echo "从1到100的和是:$sum"
[root@clb1 shell]# bash sum100.3.sh
从1到100的和是:5050

sh复制代码[root@clb1 shell]# cat sumx.sh
#!/bin/bash
read -p "请输入的数字" x
i=1
sum=0
while [ $i -le $x ];do
    let sum=sum+i
    let i++
done
echo "1到$x的和是$sum"
[root@clb1 shell]# sh sumx.sh
请输入的数字10
1到10的和是55

sh复制代码#!/bin/bash
read -t 3 -p "请在3秒内请输入的数字" x
sum=0
for ((i=1;$i<=$x;i++));do
    let sum=sum+i
done
echo "1到$x的和是$sum"

sh复制代码[root@clb1 shell]# basename /root/shell/sumx.sh
sumx.sh
[root@clb1 shell]# basename /root/shell/sumx.sh .sh
sumx

sh复制代码[root@clb1 shell]# dirname /root/shell/sumx.sh
/root/shell

sh复制代码[root@clb1 shell]# cat zhixing.sh
#!/bin/bash
i=0
for f in `ls /root/shell/*.txt`;do
    basename=`basename $f .txt`
    file=$basename".sh"
    mv $f $file
    let i++
    echo "已更改$i个文件"
    echo "本次已经修改源文件$f变为$file"
done

sh复制代码[root@clb1 shell]# cat zidingyi.1.sh
#!/bin/bash
#自定义函数
function sum(){
    let s=$1+$2
    return $s
}
sum 100 200
echo $?
[root@clb1 shell]# sh zidingyi.1.sh
44
[root@clb1 shell]# cat zidingyi.2.sh
#!/bin/bash
#自定义函数
function sum(){
    let s=$1+$2
    return $s
}
sum 10 200
echo $?
[root@clb1 shell]# sh zidingyi.2.sh
210

sh复制代码[root@clb1 shell]# cat zidingyi.3.sh
#!/bin/bash
#自定义函数
function sum(){
    let s=$1+$2
    echo $s
}
result=`sum 100 200`
echo $result
[root@clb1 shell]# sh zidingyi.3.sh
300

sh复制代码[root@clb1 shell]# cat jiecheng.sh
#!/bin/bash
if [ $1 -eq 1 ];then
    echo "参数错误，程序退出！"
    exit 3 #返回的状态码 也就是echo #？输出的
fi
function jiecheng(){
    n=$1
    if [ $n -le 1 ];then
        echo 1  #当n=1的时候，函数的返回值
        return 0 #返回的执行状态
    elif [ $n -gt 1 ];then
        let pre_n=$n-1
        temp=$(jiecheng $pre_n)
    		let result=n*temp
	  		echo $result
	  		return 0
    fi
}
jiecheng $1
[root@clb1 shell]# sh jiecheng.sh 5
120

sh复制代码[root@clb1 shell]# echo $PATH | cut -d : -f1
/usr/local/sbin
[root@clb1 shell]# grep "/bin/bash$" /etc/passwd |cut -d : -f1
root

sh复制代码[root@clb1 shell]# awk -F ":" 'BEGIN{print "username,shell"} $NF ~ "/bin/bash$"{print $1","$NF} END{print "END"}' /etc/passwd
username,shell
root,/bin/bash
END

java复制代码   // 创建一个Node
   Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
       return new Node<>(hash, key, value, next);
   }

java复制代码   // 创建一个TreeNode
   TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
       return new TreeNode<>(hash, key, value, next);
   }

java复制代码   //可以自定义初始容量initialCapacity和加载因子loadFactor
    public HashMap(int initialCapacity, float loadFactor) {
        ...                                     loadFactor);
        this.loadFactor = loadFactor;
        //初始化扩容阀值，此时不会更具initialCapacity实例化table的，此时table的为空。
        this.threshold = tableSizeFor(initialCapacity);
    }
    //默认加载因子loadFactor，DEFAULT_LOAD_FACTOR = 0.75
    //值0.75是一个在时间和空间成本上取得较好平衡的经验值。它是工程领域基于大量实验和实践得出的结果，对大多数情况来说提供了良好的性能
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    //无参构造，此时
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
    }
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    } 
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {//evict,指明是否要替换已有的映射
        int s = m.size();
        if (s > 0) {
            //如果当前table为空，重新计算threshold
            if (table == null) { // pre-size
                //通过当前的装载因子来除，得到了在保持装载因子不变的情况下，理论上所需要的桶(bucket)数量,也就是table数组的大小
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)//如果t大于当前的threshold值，重新设置threshold
                    threshold = tableSizeFor(t);//更具容量重新计算
            }
            else if (s > threshold)
                resize();//扩容
            //循环追加value    
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }
    //返回大于等于给定目标容量的最小2的n次方的数
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

java复制代码{
    int n = 16 - 1; // n = 15, 即二进制的 0000 1111

    n |= n >>> 1;   // n = 0000 1111 | 0000 0111 = 0000 1111
    n |= n >>> 2;   // n = 0000 1111 | 0000 0011 = 0000 1111
    n |= n >>> 4;   // n = 0000 1111 | 0000 0000 = 0000 1111
    n |= n >>> 8;   // 对于一个int类型，8位和16位的移动不会改变值，因为数字已经足够大
    n |= n >>> 16;  // 确保覆盖所有可能的1位

    return n + 1;   // n = 15 + 1 = 16
}

{
   int n = 18 - 1; // n = 17, 即二进制的 0001 0001

    n |= n >>> 1;   // n = 0001 0001 | 0000 1000 = 0001 1001
    n |= n >>> 2;   // n = 0001 1001 | 0000 0110 = 0001 1111
    n |= n >>> 4;   // n = 0001 1111 | 0000 0001 = 0001 1111
    n |= n >>> 8;   // n = 0001 1111 | 0000 0000 = 0001 1111
    n |= n >>> 16;  // n = 0001 1111 | 0000 0000 = 0001 1111

    return n + 1;   // n = 31 + 1 = 32  
}

java复制代码 putVal(hash(key), key, value, false, evict);

java复制代码//静态方法，
static final int hash(Object key) {
    int h;
    //(h = key.hashCode()) ^ (h >>> 16) 使用  key.hashCode()计算h,h 与 （h >>> 16 ）异或运算
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

java复制代码 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果当前为空，则进行扩容，即初始化table大小
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

        //按照 (n - 1) & hash 来寻找下标，n为当前table的大小，可以理解为对hash 的（n-1）取模。
        //如果此时对应下标为空，则直接添加。
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
             
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p; // //如果k值已经存在，并且相等,后面根据onlyIfAbsent覆盖原来的值。
            else if (p instanceof TreeNode)
            //p为当前相同hash值的链表第一个，如果当前已经是TreeNode，根据红黑树结构添加节点，后面将红黑树在细讲
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //否则轮询p链表，
                for (int binCount = 0; ; ++binCount) {
                    //到链表结尾，也没有相同的key值，就添加到链尾
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //!!!!!!!!!!
                        //添加完了，再次判断 当前p链表的节点数是不是大于等于8（TREEIFY_THRESHOLD = 8），如果是的尝试将该链表树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //有相同的，则替换
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //添加成功，size增加一个，并判断是否大于threshold阈值，如果大于就有触发一次扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
     //将一个hash bin（哈希桶）中的节点 尝试变成红黑树结构
     final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        //!!!!!!
        // MIN_TREEIFY_CAPACITY = 64
        //如果tab.length < MIN_TREEIFY_CAPACITY ,此时table的个数小于64 个，就直接扩容一次，
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                //将节点变成TreeNode
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;//hd 链表头指针
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);

            if ((tab[index] = hd) != null)
            //如果大于64，就将hd有链表结构整理变成红黑树结构
                hd.treeify(tab);
        }
    }