分类 软件开发 下的文章

go语言中的struct定义方式与C语言类似

type Human struct {
    Name string
    Age int
}

同时go语言还支持匿名字段（嵌入字段）的定义

type Student struct {
    Human
    Grade int
}

上述代码中的Human就是一个匿名字段，这个功能相当于其他语言中的继承
只要Human字段嵌入到了Student中，那么Student就默认包含了Human的所有字段
可以采用这种方式来赋值

student := new(Student)
student.Name = "小明"
student.Age = 18

也可以采用这样的方式

student := new(Student)
human := new(Human)
human.Name = "小明"
human.Age = 18
student.Human = human

闲来无事把周五商老板说的面试题解了一下
具体代码如下(Golang)

package main

import (
    "fmt"
)

const SIZE = 6
var a = [SIZE][SIZE] int {
    {2, 2, 3, 3, 5, 6},
    {2, 1, 3, 3, 4, 6},
    {2, 2, 2, 1, 1, 6},
    {1, 2, 4, 4, 5, 5},
    {2, 2, 2, 1, 1, 5},
    {1, 4, 4, 1, 3, 3},
}

var count int = 0 // 计数
var mark = [SIZE][SIZE] int {} // 用来标记该数字是否被遍历过

func main() {

    fmt.Println("原数据:", "\n")
    lenA := len(a); 
    for i := 0; i < lenA ; i++ {
        fmt.Println(a[i])
    }

    fmt.Println("\n计算结果:")

    for i := 0; i < lenA; i++ {
        lenX := len(a[i])
        for j := 0; j < lenX; j++ {
            if mark[i][j] == 0 {
                findSame(i, j, a[i][j])
                count ++
            }
        }
    }

    fmt.Printf("共%d个簇\n\n", count)

    fmt.Println("具体情况如下:\n")
    lenMark := len(mark)
    for i := 0; i < lenMark ; i++ {
        fmt.Println(mark[i])
    }
}

func findSame(i, j, x int) {

    tempI := i
    tempJ := j
    if mark[i][j] == 0 {

        mark[i][j] = count + 1
        // 往上找相同的数
        for {
            i--
            if i < 0 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
        }
        // 往下
        i = tempI
        for {
            i++
            if i > SIZE - 1 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
            
        }
        // 往左
        i = tempI
        for {
            j--
            if j < 0 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
        }
        // 往右
        j = tempJ
        for {
            j++
            if j > SIZE - 1 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
        }
    }
}

更新

经商老板指点，findSame中的for循环没必要。下面是改过之后的findSame

func findSame(i, j, x int) {

    if mark[i][j] == 0 {
        mark[i][j] = count + 1
        // 往上找相同的数
        if i-1 >= 0 && a[i-1][j] == x {
            findSame(i-1, j, a[i-1][j])
        }
        // 往下
        if i+1 < SIZE && a[i+1][j] == x {
            findSame(i+1, j, a[i+1][j])
        }
        // 往左
        if j-1 >= 0 && a[i][j-1] == x {
            findSame(i, j-1, a[i][j-1])
        }
        if j+1 < SIZE && a[i][j+1] == x {
            findSame(i, j+1, a[i][j+1])
        }
    }
}

对递归理解还是不够到位啊~不过现在应该OK了^_^

1、以管理员身份登录mysql
mysql -u root -p

2、选择mysql数据库
use mysql

3、创建用户并设定密码
insert into user (Host,User,Password) values ('localhost', 'test',password('1234'))

4、使操作生效
flush privileges

5、为用户创建数据库
create database testdb

6、为用户赋予操作数据库testdb的所有权限
grant all privileges on testdb.* to test@localhost identified '1234'

7、使操作生效
flush privileges

8、用新用户登录
mysql -u test -p

MySQL的事务支持不是绑定在MySQL服务器本身，而是与存储引擎相关。

  1. MyISAM：不支持事务，用于只读程序提高性能
  2. InnoDB：支持ACID事务、行级锁、并发
  3. Berkeley DB：支持事务

一个事务是一个连续的一组数据库操作，就好像它是一个单一的工作单元进行。换言之，只有该组内的每个单独的操作都是成功的，才是完整的事务。如果在事务的任何操作失败，则整个事务将失败。

事务 ACID Atomicity（原子性）、Consistency（一致性）、Isolation（隔离性）、Durability（持久性）
事务有以下四个标准属性的缩写ACID，通常被称为：
原子性: 确保工作单元内的所有操作都成功完成，否则事务将被中止在故障点，和以前的操作将回滚到以前的状态。
一致性: 确保数据库正确地改变状态后，成功提交的事务。
隔离性: 使事务操作彼此独立的和透明的。
持久性: 确保提交的事务的结果或效果的系统出现故障的情况下仍然存在。

1、事务的原子性
一组事务，要么成功；要么撤回。

2、一致性
有非法数据（外键约束之类），事务撤回。

3、隔离性
事务独立运行。
一个事务处理后的结果，影响了其他事务，那么其他事务会撤回。
事务的100%隔离，需要牺牲速度。

4、持久性
软、硬件崩溃后，InnoDB数据表驱动会利用日志文件重构修改。

原文链接

昨天发现阿里云有一个学生版的服务器，一个月才10元，于是不要脸了一把，用我在读同学的阿里帐号买了一台，这样一来还是比较划算的。主要是我买了也不怎么用。
今天买了之后就立马开始移植这个博客，首先装了php5，然后是nginx，php5-fpm，mysql，装好之后稍稍配置一下nginx和php5-fpm，之后开启nginx + php-fpm + mysql，又把之前服务器上的代码和数据库拷贝了一份过来。绑好域名就开始访问了，没想到竟然不行，告诉我database无法连接，我以为是用户名密码输错了，检查几次无果，然后打开typecho的debug模式，找到报错的位置，最后发现是由于没有mysql_connect这个函数导致的，这时我才意识到是没装php5-mysql，装了以后刷新页面，一切正常~

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5